Macros and Conditionals/fr: what changed

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

Old	New		Line
1	1		# Généralité
2	2
3	3		Des macros peuvent être utilisées dans les chemins de recherche et les noms de fichier pour laisser l'EDI les adapter à la plate-forme cible. Les macros de construction sont des macros spécifiques au projet/paquet. Elles ne sont pas passées au compilateur. Un exemple important est la LCLWidgetType, laquelle est définie dans le paquet LCL et permet de choisir le jeu de widgets (carbon, gtk, qt, win32, wince, ...).
4	4
5	5		Les conditionnelles sont des règles permettant de mettre des macros dépendantes de la palte-forme cible et/ou d'autres macros. Par exemple, vous pouvez les utiliser pour définir des options spéciales de l'éditeur de lien pour Mac OS X. Elle utilisent un langage de script comme Pascal pour définir des règles complexes.
6	6
7	7		Vous pouvez définir les macros de construction via [[IDE Window: Compiler Options\|Project / Project Options / Compiler Options / Additions and Overrides (en)]]
8	8
9	9		Vous pouvez faire des conditionnelles via Projet / Options du projet / Options du compilateur / Options personnalisées.
10	10
11	11		Les macros de construction et les conditionnelles existent depuis Lazarus 0.9.29.
12	12
13		-	~~<figure>~~
14		-	~~<img src="CompilerAdditionsAndOverrides1.png" title="CompilerAdditionsAndOverrides1.png" />~~
15		-	~~<figcaption>CompilerAdditionsAndOverrides1.png</figcaption>~~
16		-	~~</figure>~~
	13	+	![](/wiki-images/c/cd/CompilerAdditionsAndOverrides1.png)
17	14
18	15		# Conditionnelles
19	16
20	17		Les expressions conditionnelles utilisent un langage de scripting simple.
21	18
22	19		## Changement des options du compilateur avec les expressions conditionnelles
23	20
24	21		Le script de conditionnelles peut définir certaines variables dont les valeurs sont utilisées par l'EDI pour les options du compilateur :
25	22
26	23		- UnitPath: ajouté en fin de Autres fichiers sources (-Fu). Les caractères / et \\ sont automatiquement convertis vers le séparateur de chemin courant. Après avoir ajouté le(s) chemin(s) de recherche) avec un point-virgule, les macros sont remplacées et les chemins relatifs sont expansés par le chemin d'accès du projet/paquet.
27	24		- IncPath: ajouté en fin de Fichiers d'inclusion (-Fi).
28	25		- LibraryPath: ajouté en fin de Bibliothèques (-Fl).
29	26		- SrcPath: ajouté en fin de Autres sources (non utilisé par le compilateur, uniquement par l'EDI).
30	27		- DebugPath: ajouté en fin de Ajout de chemin du débogueur (non utilisé par le compilateur ni par les outils de code, seulement par le débogueur)
31	28		- LinkerOptions: ajouté en fin des options de l'éditeur de liens (-k). Les délimiteurs de chemin ne sont pas changés. Les chemins relatifs ne sont pas expansés. Les macros sont remplacées.
32	29		- CustomOptions: ajouté en fin des paramètres du compilateur. Les délimiteurs de chemin ne sont pas changés. Les chemins relatifs ne sont pas expansés. Les macros sont remplacées.
33	30		- OutputDir: si défini, il remplacera le dossier de sortie courant. Les délimiteurs de chemin sont changés. Les chemins relatifs sont expansés. Les macros sont remplacées.
34	31
35	32		Pour les paquets, il y a plus de variables pour les options d'usage. Ces chemins sont hérités, cela signifie qu'ils sont ajoutés à tous les paquets/projets utilisant ce paquet, directement ou non :
36	33
37	34		- UsageUnitPath : ajouté en fin du chemin d'usage Unité (-Fu). Les caractères / et \\ sont automatiquement convertis dans le séparateur de chemin actuel. Après avoir ajouté le(s) chemin(s) de recherche) avec un point-virgule, les macros sont remplacées et les chemins relatifs sont expansés par le chemin d'accès du projet/paquet.
38	35		- UsageIncPath : ajouté en fin du chemin d'usage Inclusion (-Fi).
39	36		- UsageLibraryPath : ajouté en fin du chemin d'usage Bibliothèque (-Fl).
40	37		- UsageSrcPath : ajouté en fin du chemin d'usage Source (pas utilisé par le compilateur, seulement l'EDI).
41	38		- UsageDebugPath : ajouté en fin du chemin d'usage Débogueur (pas utilisé par le compilateur, ni par les outils de code, utilisé seulement par le débogueur).
42	39		- UsageLinkerOptions : ajouté en fin des options de l'éditeur de liens (-k). Les délimiteurs de chemin ne sont pas changés. Les chemins relatifs ne sont pas expansés. Les macros sont remplacées.
43	40		- UsageCustomOptions : ajouté en fin des paramètres d'usage du compilateur. Les délimiteurs de chemin ne sont pas changés. Les chemins relatifs ne sont pas expansés.
44	41
45	42		## Syntaxe des expressions conditionnelles
46	43
47	44		### Constructions de syntaxe supportées
48	45
49	46		- If expression then instruction;
50	47		- If expression then instruction else instruction;
51	48		- begin instruction; ... instruction; end;
52	49		- Variable:=expression;
53	50		- Variable+=expression;
54	51		- Commentaires //, { }, (* *)
55	52		- Espaces, tabulations et saut de ligne sont les mêmes. Comme en Pascal, ils ne sont requis que pour séparer deux identificateurs/mots-clés.
56	53
57	54		### Variables
58	55
59	56		Les variables sont définies simplement en assignant une valeur. Il y a des variables prédéfinies. Voir ci-dessous pour une liste.
60	57
61	58		Les variables peuvent être définies ou indéfinies :
62	59
63	60		``` pascal
64	61		if defined(Name) then ...
65	62		if undefined(Name) then ...
66	63		undefine(Name);
67	64		```
68	65
69	66		Si une variables est définie, elle peut avoir l'un de ces trois types :
70	67
71	68		- aucun
72	69		- chaîne de caractères
73	70		- numérique (int64)
74	71
75	72		Une variable est false si elle prend la valeur numérique 0 ou chaîne '0'. Sinon, elle vaut true. Cela signifie qu'une variable sans valeur est vraie tout comme une variable indéfinie.
76	73
77	74		Vous pouvez changer le type d'une variable avec :
78	75
79	76		``` pascal
80	77		a:='1'; // string
81	78		a:=integer(a); // convertit vers un nombre en utilisant StrToInt(), en cas d'échec, la variable demeure une chaîne
82	79		a:=int64(a); // convertit vers un nombre en utilisant StrToInt64(), en cas d'échec, la variable demeure une chaîne
83	80		a:=string(a); // convertit vers une chaîne
84	81		```
85	82
86	83		### Constantes
87	84
88	85		``` pascal
89	86		a:=1234; // decimal
90	87		a:=$A1B; // hexadecimal
91	88		a:=&127; // octal
92	89		a:=%101; // binary
93	90		a:='10'; // string
94	91		a:=#123; // character
95	92		```
96	93
97	94		### Opérateurs
98	95
99	96		- + : Deux nombres sont ajoutés, sinon ils sont traités comme une chaîne et concaténés.
100	97		- \<, \>, \<=, \>=, =, \<\> : Deux nombres sont comparés mathématiquement, sinon ils sont traités comme des chaînes et comparés lexicographiquement (sensible à la casse).
101	98		- not : opérateur booléen unaire.
102	99		- and, or, xor : Opérateurs booléens.
103	100		- (,) : operations de groupe.
104	101		- := : Affectation. Pas permis dans les expressions (désolé, c'est pas du langage C).
105	102		- += : Ajout et affectation. Pas permis dans les expressions.
106	103
107	104		Niveaux de précédence:
108	105
109	106		- 1 Not et - (moins unaire)
110	107		- 1 And
111	108		- 2 Or
112	109		- 2 XOr
113	110		- 2 +
114	111		- 4 =
115	112		- 4 \<\>
116	113		- 4 \<
117	114		- 4 \<=
118	115		- 4 \>
119	116		- 4 \>=
120	117
121	118		## Variables prédéfinies
122	119
123	120		Avant que le script d'expressions conditionnelles ne soit exécuté, l'EDI initialise quelques variables :
124	121
125	122		- TargetOS : le système d'exploitation cible comme défini par fpc p.ex. 'linux', 'win32', 'darwin', 'freebsd', 'wince'.
126	123		- TargetCPU: le processeur cible du projet comme défini par fpc p.exe. 'i386', 'x86_64', 'arm'.
127	124		- SrcOS: la valeur 'win' pour toute plate-forme MS Windows et 'unix' pour toutes les plate-formes unixiennes. La valeur dépend de TargetOS.
128	125		- SrcOS2: la valeur 'bsd' pour toutes les plates-formes BSD-iennes. La valeur dépend de TargetOS.
129	126		- True : valeur 1
130	127		- False : valeur 0
131	128		- toutes les macros de construction définies par le projet en cours.
132	129		- Toutes les macros de construction définies par les paquets utilisés. Cela signifie que si le projet n'a pas défini une valeur pour une macro du paquet, la valeur de la conditionnelle du paquet utilisé sera utilisée.
133	130
134	131		## Fonction prédéfinies
135	132
136	133		- Defined(Variable) : retourne 1 (vrai) si la variable est définie et 0 (faux) sinon. Exemple if Defined(Macro1) then ;
137	134		- Undefine(Variable) : annule la définition de la variable. Exemple: Undefine(A);
138	135		- Int64(expression) : Retourne la valeur Int64 de l'expression. Exemple: i:=int64('3');
139	136		- Integer(expression) : Retourne la valeur entière d'une expression. Exemple: i:=integer('3');
140	137		- String(expression) : Retourne la valeur chaîne d'une expression. Exemple: s:=string(3);
141	138		- GetIDEValue(string) : Voir [[IDE Macros in paths and filenames\|Macros EDI (en)]].
142	139		- GetIDEValue('OS') : Retourne le système d'exploitation dans lequel l'EDI a été compilé. Depuis la version 1.0.
143	140		- GetIDEValue('CPU') : Retourne le processeur avec lequel l'EDI a été compilé. Depuis la version 1.0.
144	141		- GetIDEValue('SrcOS') : SrcOS de l'EDI. Depuis la version 1.0.
145	142		- GetIDEValue('SrcOS2') : SrcOS2 de l'EDI. Depuis la version 1.0.
146	143		- GetIDEValue('LCLWidgeType') : Plate-forme LCL de l'EDI, qui peut être différente du projet. lazbuild retourne win32, carbon ou gtk2 selon son système d'exploitation. Depuis la version 1.0.
147	144		- GetEnv(string) : Retourne la valeur de la variable d'environnement. Par exemple, GetEnv('HOME') retourne sous Linux le répertoire d'acceuil de l'utilisateur. Depuis la version 1.0.
148	145		- GetProjValue(string) : Retourne une valeur de projet.
149	146		- GetProjValue('FPC_FULLVERSION'): Retourne la FPC_FULLVERSION rapportée du compilateur. La version est un entier p.ex. 20701. Depuis la version 1.3.
150	147
151	148		# Ordre de calcul des macros
152	149
153	150		1. Les valeurs du projet courant sont reprises.
154	151		2. si le projet ne définit pas les valeurs pour TargetOS, TargetCPU, l'EDI prend les valeurs par défaut.
155	152		3. SrcOS et SrcOS2 sont calculées à partir de TargetOS.
156	153		4. Les expressions des paquets utilisés sont calculées. Si un paquet A utilise un paquet B, alors les conditionnelles du paquet B sont calculées avant les conditionnelles de A.
157	154		5. Chaque script de conditionnelles démarre avec les valeurs du projets.
158	155		- Si le projet ne définit pas une valeur pour une macro de paquet, le résultat du paquet utilise est utilisé.
159	156		- Un script peut modifier toute macro quand il s'exécute , mais seules les macros de construction et les macros prédéfinies sont utilisées. Par exemple, vous pouvez définir TargetOS à une autre valeur mais cela n'a pas d'effet sur un autre script, ni sur aucun chemin de recherche utilisant \$(TargetOS), ni même sur les chemins de recherche du paquet lui-même.
160	157		- Si deux paquets définissent la même macro de construction alors les deux peuvent modifier la valeur (à moins que le projet définisse une valeur). L'effet exact dépend de l'ordre des dépendances.
161	158		6. les macros par défaut de l'EDI sont définies en dernier.
162	159
163	160		# Exemples
164	161
165	162		## Ajout d'un drapeau de compilateur pour la cible Unix
166	163
167	164		``` pascal
168	165		if TargetOS = 'linux' then
169	166		CustomOptions := '-dUseCThreads';
170	167		```
171	168
172	169		Notes :
173	170
174	171		- TargetOS est une macro prédéfinie par l'EDI.
175	172		- CustomOptions est une variable de resultat utilisée par l'EDI.
176	173		- Les identificateurs sont sensibles à la casse, mais l'opérateur = ne l'est pas. La macro TargetOS utilise la même que le compilateur, qui est actuellement la bas-de-casse (minuscules)
177	174		- L'EDI ajoute le premier espace automatiquement lors de l'ajout d'options personnalisées.
178	175		- Lorsqu'il est utilisé dans un paquet, ce qui précède sera uniquement appliqué aux options utilisées pour la compilation du paquet et non au projet utilisant le paquet.
179	176
180	177		## Ajout de quelques options de l'éditeur de liens pour la cible Mac OS X
181	178
182	179		Le compilateur utilise pour Mac OS X la valeur darwin pour TargetOS.
183	180
184	181		``` pascal
185	182		if TargetOS = 'darwin' then begin
186	183		LinkerOptions += ' -framework Cocoa';
187	184		if TargetCPU = 'i386' then
188	185		LinkerOptions += ' -framework OpenGL';
189	186		end;
190	187		```
191	188
192	189		Notes:
193	190
194	191		- TargetOS et TargetCPU sont des macros prédéfinies par l'EDI.
195	192		- L'opérateur += ajoute une chaîne ou ajoute un nombre.
196	193		- En ajoutant plusieurs options, vous devez ajouter une espace entre les options.
197	194		- L'EDI ajoute la première espace automatiquement lors de l'ajout des options de l'éditeur de liens.
198	195		- Vous pouvez imbriquer begin..end comme en Pascal.
199	196		- Si les deux conditions sont vérifiées ensemble, LinkerOptions contiendra la valeur ' -framework Cocoa -framework OpenGL'.
200	197		- L'EDI fait précéder l'option -k quand sont passées au compilateur des options de l'éditeur de liens.
201	198		- Ce qu'il y a en haut ne marche que pour les conditionnelles de projet.
202	199
203	200		## Ajout de quelques options de l'éditeur de liens pour Mac OS X pour tous les projets utilisant un paquet
204	201
205	202		Les paquets ont deux jeux différents d'options. Le jeu utilisé pour la compilation du paquet lui-même et les options ajoutées à tous les projets/paquets utilisant le paquet. Vous devez changer les options d'usage du paquet :
206	203
207	204		``` pascal
208	205		if TargetOS = 'darwin' then begin
209	206		UsageLinkerOptions += ' -framework Cocoa';
210	207		if TargetCPU = 'i386' then
211	208		UsageLinkerOptions += ' -framework OpenGL';
212	209		end;
213	210		```
214	211
215	212		## Ajout d'une option à un paquet
216	213
217	214		Si votre paquet fournit des parties optionnelles, par exemple la capacité d'utiliser OpenGL vous pouvez définir une macro de construction. Ce qui suit explique comment définir ceci pas à pas :
218	215
219	216		Disons que votre paquet est appelé Pkg1 et permet de basculer sur le support d'OpenGL en le compilant avec le drapeau -dEnableOpenGL. Le paquet devrait fournir une option booléenne Pkg1_UseOpenGL avec la valeur 'True' and 'False'.
220	217
221	218		Ouvrez l'éditeur de paquet de votre paquet 'pkg1', cliquez sur Options du compilateur et sélectionnez la page Macros de l'EDI.
222	219
223	220		Cliquez sur bouton + de gauche pour ajouter une nouvelle macro. Elle sera appelée 'Pkg1_Macro1'. Cliquez sur le noeud de l'arbre pour le renommer 'Pkg1_UseOpenGL'.
224	221
225	222		Cliquez sur le bouton + du milieu pour ajouter une nouvelle valeur de macro. Elle sera appelée 'Value1'. Cliquez sur le noeud de l'arbre pour le renommer en 'True'. Recommencez ceci pour ajouter 'False'.
226	223
227	224		Ajoutez le code suivant dans la boîte de texte des conditionnelles (Options du compilateur / Options personnalisées)
228	225
229	226		``` pascal
230	227		if Pkg1_UseOpenGL='True' then
231	228		CustomOptions := '-dEnableOpenGL';
232	229		```
233	230
234		-	~~<figure>~~
235		-	~~<img src="Compileroptions_buildmacro_example1.png" title="Compileroptions_buildmacro_example1.png" />~~
236		-	~~<figcaption>Compileroptions_buildmacro_example1.png</figcaption>~~
237		-	~~</figure>~~
	231	+	![](/wiki-images/c/c2/Compileroptions_buildmacro_example1.png)
238	232
239	233		Notes:
240	234
241	235		- La valeur 'True' est sensible à la casse. Comme la valeur est en général choisie à partir d'une combobox, il y a peu de chance d'erreur typographique.
242	236		- Si l'utilisateur n'a pas défini de valeur pour la macro, la variable 'Pkg1_UseOpenGL' est indéfinie et l'expression est évaluée en 'False'.
243	237
244	238		## Ajouter un mode release/debug
245	239
246	240		### Un mode release/debug pour votre projet et tous vos paquets
247	241
248	242		Note: Ceci nécessite Lazarus Lazarus 0.9.31 ou supérieur.
249	243
250	244		Dans les options du compilateur (Projet / Options du projet / Options du compilateur / Modes de construction) ajoutez un mode Release. Ajouter ce mode de construction l'activera automatiquement, ainsi tous les changements des options du compilateur porteront maintenant uniquement sur ce mode.
251	245
252	246		Dans "Définir les valeurs de macro", cliquez sur la colonne de gauche sur la dernière ligne "(none)". Mettez-la à "MyPackageOptions". Note : elle n'est pas listée dans la combo box.
253	247
254	248		Mettez comme valeur les options, par exemple "-O3".
255	249
256		-	~~<figure>~~
257		-	~~<img src="Build_mode_release_macro1.png" title="Build_mode_release_macro1.png" />~~
258		-	~~<figcaption>Build_mode_release_macro1.png</figcaption>~~
259		-	~~</figure>~~
	250	+	![](/wiki-images/1/1f/Build_mode_release_macro1.png)
260	251
261	252		Cette macro est utilisable dans les options du compilateur du projet et tous les paquets.
262	253
263	254		Pour chaque paquet, faites : ouvrir les options du compilateur du paquet, aller à la page Autres. Ajoutez aux Options personnalisée le texte \$(MyPackageOptions).
264	255
265	256		### Un mode release/debug spécial pour un paquet
266	257
267	258		Admettons que le mode normal est le mode Debug et que vous voulez un autre mode pour les releases.
268	259
269	260		Ouvrez l'éditeur de paquet de votre paquet 'pkg1', cliquez sur Options du compilateur", sélectionnez la pageMacros de contruction''.
270	261
271	262		Sous Macros de construction cliquez sur le bouton + de gauche pour ajouter une nouvelle macro. Elle sera appelée 'Pkg1_Macro1'. Cliquez sur le noeud de l'arbre pour le renommer en 'Pkg1_Release'.
272	263
273	264		Cliquer sur le bouton '+' du milieu pour ajouter une nouvelle valeur de macro. Elle sera appelée 'Value1'. Cliquez sur le noeud de l'arbre pour le renommer en 'True'. Répéter la dernière opération pour la valeur 'False'.
274	265
275	266		Ajoutez le code suivant dans la boîte de texte des expressions conditionnelles :
276	267
277	268		``` pascal
278	269		if Pkg1_Release='True' then
279	270		// release mode
280	271		CustomOptions := '-O3'
281	272		else
282	273		// debug mode
283	274		CustomOptions := '-Sa Ctroi';
284	275		```
285	276
286	277		Notes:
287	278
288	279		- La valeur 'True' est sensible à la casse. Parce que la valeur est en général sélectionnée depuis une combo box, il y a peu de chance d'erreur de saisie.
289	280		- Si l'utilisateur n'a pas défini de valeur de la macro, la variable 'Pkg1_Release' est indéfinie et le résultat de l'expression est 'False'.
290	281
291	282		## Ajout d'une macro pour les chemins de recherche pour gérer plusieurs plates-formes
292	283
293	284		Disons que votre paquet est appelé Pkg1 et qu'il utilise le GDI dans MS Windows et X11 dans Linux et BSD. Les unités indépendantes de la plate-forme sont dans le dossier principal du paquet et vous avez créé deux sous-dossiers 'gdi' et 'x11' contenant les unités dépendantes de la plate-forme :
294	285
295	286		/path/of/your/package/pkg1/
296	287		pkg1.lpk
297	288		pkg1.pas
298	289		generalunit.pas
299	290		gdi/
300	291		backend.pas
301	292		x11/
302	293		backend.pas
303	294
304	295		L'unité backend dans gdi devrait être utiliser dans Win32, Win64 et WinCE, alors que sous Linux et FreeBSD l'unité backend devrait être utilisée dans le x11. Ceci signifie que le chemin de recherche Autres fichiers d'unité (-Fu) doit être adapté selon le système cible. Ce qui suit décrit comment régler ceci pas à pas :
305	296
306	297		Ouvrez l'éditeur de paquet de votre paquet 'pkg1', cliquez sur les options de compilateur, sélectionnez la page Macros de construction.
307	298
308	299		Cliquez sur le bouton + de gauche pour ajouter une nouvelle macro. Elle sera appelée 'Pkg1_Macro1'. Cliquez sur le nœud de l'arbre pour le renommer en 'Pkg1_Backend'.
309	300
310	301		Cliquez sur le bouton + du milieu pour ajouter une nouvelle valeur de macro. Elle sera appelée 'Value1'. Cliquez sur le nœud de l'arbre pour le renommer en 'gdi'. Répéter l'opération pour la valeur 'x11'.
311	302
312	303		Ajoutez le code suivant dans la boîte de texte des conditionnelles :
313	304
314	305		``` pascal
315	306		// choisissez le valeur de Pkg1_Backend selon le système cible
316	307		if undefined(Pkg1_Backend) then begin
317	308		if SrcOS='win' then
318	309		Pkg1_Backend:='gdi'
319	310		else
320	311		Pkg1_Backend:='x11';
321	312		end;
322	313		```
323	314
324	315		La macro \$(Pkg1_Backend) deviendra utilisable une fois que vous aurez cliquer sur 'Ok' pour fermer les options du compilateur et l'avoir réouvert pour l'utiliser dans les chemins de recherche Autres fichiers d'unité (-Fu).
325	316
326		-	~~<figure>~~
327		-	~~<img src="Compileroptions_buildmacro_example2.png" title="Compileroptions_buildmacro_example2.png" />~~
328		-	~~<figcaption>Compileroptions_buildmacro_example2.png</figcaption>~~
329		-	~~</figure>~~
	317	+	![](/wiki-images/7/70/Compileroptions_buildmacro_example2.png)
330	318
331	319		Notes:
332	320
333	321		- L'utilisateur peut surcharger la valeur de Pkg1_Backend. C'est donc une bonne pratique d'entourer les réglages (settings) dans un bloc if undefined(Pkg1_Backend).
334	322		- A la place de la macro SrcOS, vous pourriez utiliser if (TargetOS='win32') or (TargetOS='win64') or (TargetOS='wince') then.
335	323
336	324		---
337	325		From the Free Pascal wiki, page "Macros and Conditionals/fr", as it stood on 2020-02-19 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