The parse tree/fr: what changed

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

Old	New		Line
1	1		Retour au contenu [[FPC internals/fr\|FPC internals]]
2	2
3	3		# L'arbre syntaxique
4	4
5	5		## Architecture
6	6
7	7		(dernière mise à jour pour fpc version 1.0.x)
8	8
9	9		L'arbre est la base du compilateur. Quand le compilateur analyse les instructions et les blocs de code, ils sont convertis en une représentation d'arbre. Cet représentation d' arbre est actuellement une liste doublement chaînée. Depuis cet arbre, la génération de code peut être facilement implémentée.
10	10
11	11		En supposant que vous avez la syntaxe Pascal suivante :
12	12
13	13		`x := x * y + (6 shl x);`
14	14
15	15		L'arbre de structure sera construit en mémoire, où chque cercle représente un élément (un noeud) dans l'arbre :
16	16
17	17		<http://www.pjh2.de/fpc/CompilerInternalsFigure03.png>
18	18
19	19		## Types de noeud
20	20
21	21		(dernière mise à jour pour fpc version 2.1.1, 2005-06-11)
22	22
23	23		Les noeuds possible dans l'arbre sont (de type TNodeTyp):
24	24
25	25		\| Tree type definition \| Description \|
26	26		\|----\|----\|
27	27		\| emptynode \| Aucun node (retourne nil au chargement depuis le ppu) \|
28	28		\| addn \| Répresente l'opérateur + \|
29	29		\| muln \| Répresente l'opérateur * \|
30	30		\| subn \| Répresente l'opérateur - \|
31	31		\| divn \| Répresente l'opérateur `div` \|
32	32		\| symdifn \| Répresente l'opérateur \>\< \|
33	33		\| modn \| Répresente l'opérateur `mod` \|
34	34		\| assignn \| Répresente l'opérateur := (affectation) \|
35	35		\| loadn \| Répresente l'utilisation d'une variable \|
36	36		\| rangen \| Répresente un intervalle (i.e. 0..9) \|
37	37		\| ltn \| Répresente l'opérateur \< \|
38	38		\| lten \| Répresente l'opérateur \<= \|
39	39		\| gtn \| Répresente l'opérateur \> \|
40	40		\| gten \| Répresente l'opérateur \>= \|
41	41		\| equaln \| Répresente l'opérateur = \|
42	42		\| unequaln \| Répresente l'opérateur \<\> \|
43	43		\| inn \| Répresente l'opérateur `in` \|
44	44		\| orn \| Répresente l'opérateur `or` \|
45	45		\| xorn \| Répresente l'opérateur `xor` \|
46	46		\| shrn \| Répresente l'opérateur `shr` \|
47	47		\| shln \| Répresente l'opérateur `shl` \|
48	48		\| slashn \| Répresente l'opérateur / \|
49	49		\| andn \| Répresente l'opérateur `and` \|
50	50		\| subscriptn \| Répresente un champ dans un oibjet ou un enregistrement \|
51	51		\| derefn \| Répresente une déréférence de pointeur (telle qu'avec l'opérateur ^) \|
52	52		\| addrn \| Répresente l'opérateur @ \|
53	53		\| ordconstn \| Représente une constante ordinale \|
54	54		\| typeconvn \| Représente une conversion de type \|
55	55		\| calln \| Représente un appel de routine \|
56	56		\| callparan \| Représente un paramètre passé à une routine \|
57	57		\| realconstn \| Représente une constante en virgule flottante \|
58	58		\| unaryminusn \| Représente un signe négatif (p.ex. : -) \|
59	59		\| asmn \| Représente un noeud d'instruction assembleur \|
60	60		\| vecn \| Représente l'indexation d'un tableau \|
61	61		\| pointerconstn \| Représente une constante de type pointer \|
62	62		\| stringconstn \| Représente une constante de type string \|
63	63		\| notn \| Répresente l'opérateur `not` \|
64	64		\| inlinen \| Répresente une des routines internes (writeln,ord,etc.) \|
65	65		\| niln \| Représente le pointeur `nil` \|
66	66		\| errorn \| Représente une erreur dans l'analyse de ce noeud (utilisé pour la détection d'erreur et la correction) \|
67	67		\| typen \| Représente un nom de type (i.e typeof(obj)) \|
68	68		\| setelementn \| Représente des ensembles d'éléments (i.e : \[a..b\], \[a,b,c\]) (non constant) \|
69	69		\| setconstn \| Représente un ensemble d'éléments constants i.e : \[1..9\], \[1,2,3\]) \|
70	70		\| blockn \| Représente un bloc d'instructions \|
71	71		\| statementn \| Représente une instruction dans un bloc de noeuds \|
72	72		\| ifn \| Représente une instruction `if` \|
73	73		\| breakn \| Représente une instruction `break` \|
74	74		\| continuen \| Représente une instruction `continue` \|
75	75		\| whilerepeatn \| Représente une instruction `while` ou `repeat` \|
76	76		\| forn \| Représente une instruction `for` \|
77	77		\| exitn \| Représente une instruction `exit` \|
78	78		\| withn \| Représente une instruction `with` \|
79	79		\| casen \| Représente une instruction `case` \|
80	80		\| labeln \| Représente une instruction `label` \|
81	81		\| goton \| Représente une instruction `goto` \|
82	82		\| tryexceptn \| Représente une instruction `try..except` \|
83	83		\| raisen \| Représente une instruction `raise` \|
84	84		\| tryfinallyn \| Représente une instruction `try..finally` \|
85	85		\| onn \| Représente une instruction `on..do` (dans le code de traitement d'une exception) \|
86	86		\| isn \| Répresente l'opérateur `is` \|
87	87		\| asn \| Répresente l'opérateur de conversion de type `as` \|
88	88		\| caretn \| Répresente l'opérateur ^ \|
89	89		\| starstarn \| Répresente l'opérateur ** (exponentiation) \|
90	90		\| arrayconstructorn \| Répresente un noeud de construction pour l'analyse de for \[...\] \|
91	91		\| arrayconstructorrangen \| Elément d'intervalle pour permettre aux ensembles dans l'arbre de construction d'un tableau \|
92	92		\| tempcreaten \| pour les temporaires dans le result/firstpass \|
93	93		\| temprefn \| Références vers temporaires. \|
94	94		\| tempdeleten \| Pour les temporaires dans le result/firstpass \|
95	95		\| addoptn \| Ajouté pour les optimisations où nous ne pouvons pas supprimer. \|
96	96		\| nothingn \| NOP, Ne fait rien \|
97	97		\| loadvmtaddrn \| Charge l'adresse de la VMT d'une classe/d'un objet \|
98	98		\| guidconstn \| Une constante GUID d'interface COM \|
99	99		\| rttin \| Informations Rtti pour qu'elles soient accessibles dans result/firstpass \|
100	100		\| loadparentfpn \| Charge le framepointer du parent pour les procédures imbriquées. \|
101	101
102	102		## Champs de structure de noeud (node.pas)
103	103
104	104		(dernière mise à jour pour fpc version fpc version 2.1.1, 2005-06-11)
105	105
106		-	~~`type`\~~
107		-	~~` TNode = ``class`\~~
108		-	~~` public`\~~
109		-	~~` NodeType: TNodeType; // type de ce noeud`\~~
110		-	~~` BlockType: TBlock_Type; // type du bloc de code courant, général/const/type`\~~
111		-	~~` ExpectLoc: TCGLoc; // emplacement attendu du résultat de ce noeud (pass1)`\~~
112		-	~~` Location: TLocation; // l'emplacement du résultat de ce noeud (pass2)`\~~
113		-	~~` Parent: TNode; // le noeud parent de ce noeud`\~~
114		-	~~` // ce champ est est défini par concattolist `\~~
115		-	~~` Flags: TNodeFlags; // il y a quelques propriétés sur la noeud enregistré`\~~
116		-	~~` PpuIdx: Longint;`\~~
117		-	~~` RegistersInt, // le nombre de registres nécessaires pour évaluer ce noeud`\~~
118		-	~~` RegistersFpu,`\~~
119		-	~~` RegistersMm: Longint; // doit être longint !!!! `\~~
120		-	~~` {$ifdef SUPPORT_MMX}`\~~
121		-	~~` RegistersMmx: Longint;`\~~
122		-	~~` {$endif SUPPORT_MMX}`\~~
123		-	~~` ResultType: TType;`\~~
124		-	~~` FileInfo: TFilePosInfo;`\~~
125		-	~~` LocalSwitches: TLocalSwitches;`\~~
126		-	~~` {$ifdef extdebug}`\~~
127		-	~~` MaxFirstPassCount,`\~~
128		-	~~` FirstPassCount: Longint;`\~~
129		-	~~` {$endif extdebug}`\~~
130		-	~~` ``end;`~~
	106	+	``` pascal
	107	+	<tt><b>type</b>
	108	+	TNode = <b>class</b>
	109	+	public
	110	+	NodeType: TNodeType; // type de ce noeud
	111	+	BlockType: TBlock_Type; // type du bloc de code courant, général/const/type
	112	+	ExpectLoc: TCGLoc; // emplacement attendu du résultat de ce noeud (pass1)
	113	+	Location: TLocation; // l'emplacement du résultat de ce noeud (pass2)
	114	+	Parent: TNode; // le noeud parent de ce noeud
	115	+	// ce champ est est défini par concattolist
	116	+	Flags: TNodeFlags; // il y a quelques propriétés sur la noeud enregistré
	117	+	PpuIdx: Longint;
	118	+	RegistersInt, // le nombre de registres nécessaires pour évaluer ce noeud
	119	+	RegistersFpu,
	120	+	RegistersMm: Longint; // doit être longint !!!!
	121	+	{$ifdef SUPPORT_MMX}
	122	+	RegistersMmx: Longint;
	123	+	{$endif SUPPORT_MMX}
	124	+	ResultType: TType;
	125	+	FileInfo: TFilePosInfo;
	126	+	LocalSwitches: TLocalSwitches;
	127	+	{$ifdef extdebug}
	128	+	MaxFirstPassCount,
	129	+	FirstPassCount: Longint;
	130	+	{$endif extdebug}
	131	+	<b>end;</b></tt>
	132	+	```
131	133
132	134		### TNodeFlag
133	135
134	136		(dernière mise à jour pour fpc version 2.1.1, 2005-06-11)
135	137
136	138		\| TNodeType \| \| Description \|
137	139		\|----\|----\|----\|
138	140		\| nf_swapable \| TBinOp \| Les opếrandes peuvent être échangées \|
139	141		\| nf_swaped \| TBinOp \| Les opérandes sont échangées \|
140	142		\| nf_error \| \| Mis à TRUE s'il y a eu une erreur en analysant ce noeud \|
141	143		\| nf_pass1_done \| général \| \|
142	144		\| nf_write \| général \| Le noeud est écrit vers \|
143	145		\| nf_isproperty \| général \| TRUE si c'est une propriété \|
144	146		\| nf_typedaddr \| TAddrNode \| \|
145	147		\| nf_no_checkpointer \| TDerefNode \| \|
146	148		\| nf_memindex \| TVecNode \| \|
147	149		\| nf_memseg \| TVecNode \| \|
148	150		\| nf_callunique \| TVecNode \| \|
149	151		\| nf_absolute \| TLoadNode \| \|
150	152		\| nf_is_self \| TLoadNode \| \|
151	153		\| nf_load_self_pointer \| TLoadNode \| \|
152	154		\| nf_is_currency \| TAddNode \| \|
153	155		\| nf_has_pointerdiv \| TAddNode \| \|
154	156		\| nf_concat_string \| TAssignmentNode \| \|
155	157		\| nf_use_strconcat \| TAssignmentNode \| \|
156	158		\| nf_forcevaria \| TArrayConstructNode \| \|
157	159		\| nf_novariaallowed \| TArrayConstructNode \| \|
158	160		\| nf_explicit \| TTypeConvNode \| \|
159	161		\| nf_internal \| TTypeConvNode \| Aucun avertissement/conseil n'a été généré. \|
160	162		\| nf_load_procvar \| TTypeConvNode \| \|
161	163		\| nf_inlineconst \| TInlineNode \| \|
162	164		\| nf_get_asm_position \| TAsmNode \| \|
163	165		\| nf_block_with_exit \| TBlockNode \| \|
164	166
165	167		### TLocalSwitches
166	168
167	169		(dernière mise à jour pour fpc version 2.1.1, 2005-06-11)
168	170
169	171		Génération de code
170	172
171	173		\| TLocalSwitches \| Commutateur \| Paramètre \| Description \|
172	174		\|----\|----\|----\|----\|
173	175		\| cs_check_overflow \| {\$Q+} \| -Co \| Le générateur de code devrait émettre du code de contrôle de débordement \|
174	176		\| cs_check_range \| {\$R+} \| -Cr, -CR \| Le générateur de code devrait émettre du code de contrôle des intervalles \|
175	177		\| cs_check_object \| \| -CR \| Le générateur de code devrait émettre du code pour vérifier la validité des appels de méthode \|
176	178		\| cs_check_io \| {\$I+} \| -Ci \| Le générateur de code devrait émettre du code de contrôle des E/S \|
177	179		\| cs_check_stack \| {\$S+} \| -Ct \| Le générateur de code devrait émettre du code de cvontrôle de la pile \|
178	180		\| cs_checkpointer \| \| -gc \| Le générateur de code devrait émettre du code de contrôle de pointeur \|
179	181		\| cs_omitstackframe \| N/A \| \| Le générateur de code ne devrait pas émettre du code d'installation de frame_pointer (frame_pointer setup) dans le code d'entrée (entry code) (n'est pas utilisé dans le compilateur) \|
180	182		\| cs_do_assertion \| {\$C+} \| -Sa \| Le générateur de code supporte l'utilisation de la routine en-ligne assert (assert inline routine) \|
181	183		\| cs_generate_rtti \| {\$M+} \| \| Le générateur de code devrait émettre de l'information de type à l'exécution (runtime type information) \|
182	184		\| cs_full_boolean_eval \| {\$B+} \| \| Mode d'évaluation des booléens \|
183	185		\| cs_typed_const_writable \| {\$J+} \| \| *todo* \|
184	186		\| cs_allow_enum_calc \| \| \| *todo* \|
185	187
186	188		MMX
187	189
188	190		\| TLocalSwitches \| Commutateur \| Paramètre \| Description \|
189	191		\|----\|----\|----\|----\|
190	192		\| cs_mmx \| {\$MMX+} \| \| Le générateur de code peut utiliser des commandes MMX \|
191	193		\| cs_mmx_saturation \| {\$SATURATION+} \| \| Le générateur de code peut utiliser des opérations saturées (MMX) \|
192	194
193	195		Parser
194	196
195	197		\| TLocalSwitches \| Commutateur \| Paramètre \| Description \|
196	198		\|----\|----\|----\|----\|
197	199		\| cs_typed_addresses \| {\$T+} \| \| L'analyseur émets des pointeurs typés utilisant l'opérateur @ \|
198	200		\| cs_strict_var_strings \| {\$V+} \| \| Les types String doivent être identiques (même longueur) pour être compatibles \|
199	201		\| cs_ansistrings \| {\$H+} \| -Sh \| L'analyseur créée une ansistring quand un type de String non spécifié est déclaré au lieu de ShortString par défaut \|
200	202
201	203		MACPAS specific
202	204
203	205		\| TLocalSwitches \| Commutateur \| Paramètre \| Description \|
204	206		\|-----------------------\|-------------\|-----------\|-------------\|
205	207		\| cs_external_var \| {\$J+} \| \| *todo* \|
206	208		\| cs_externally_visible \| {\$Z+} \| \| *todo* \|
207	209
208	210		### Champs supplémentaires
209	211
210	212		(dernière mise à jour pour fpc version 1.0.x)
211	213
212	214		Selon le type de l'arbre, quelques champs supplémentaires peuvent être présents dans le noeud de l'arbre. Cette section décrit ces champs additionnels. Avant d'accéder à ces champs additionnels, un contrôle de type de l'arbre doit toujours être fait pour vérifier si on ne lit pas des intervalles de mémoires invalides.
213	215
214	216		#### AddN
215	217
216	218		\| Champ \| Description \|
217	219		\|----\|----\|
218	220		\| Use_StrConcat: Boolean; \| Actuellement inutilisé (usage pour l'optimisation dans des versions futures) \|
219	221		\| String_Typ: TStringType; \| Au cas où l'opérateur + est appliqué sur une String, ce champ indique le type de string. \|
220	222
221	223		#### CallParaN
222	224
223	225		\| Champ \| Description \|
224	226		\|----\|----\|
225	227		\| Is_Colon_Para : Boolean; \| Utilisé par des routines internes qui peuvent utiliser des paramètres de format optionnels (utilisant des :). Défini à TRUE si ce paramètre est précédé par : (i.e. : :1) (voir [[https://wiki.freepascal.org/Write\|https://wiki.freepascal.org/Write#Signature]] par exemple). \|
226	228		\| Exact_Match_Found : Boolean; \| Défini à TRUE si le type du paramètre est est exactement Set to TRUE if the parameter type is exactly the same as the one expected by the routine. \|
227	229		\| ConvLevel1Found : Boolean; \| Défini à TRUE si le type du paramètre nécessite une conversion de type de niveau 1 pour être conforme au paramètre attendu par la routine. \|
228	230		\| ConvLevel2Found : Boolean; \| Défini à TRUE si le type du paramètre nécessite une conversion de type de niveau 2 pour être conforme au paramètre attendu par la routine. \|
229	231		\| HighTree : pTree; \| \|
230	232
231	233		#### AssignN
232	234
233	235		\| Champ \| Description \|
234	236		\|----\|----\|
235	237		\| AssignTyp: TAssignTyp; \| Inutilisé actuellement (Mis en place pour être utilisé dans les affectations à la façon C) \|
236	238		\| Concat_String: Boolean; \| Inutilisé actuellement (utilisé pour des optimisations dans des versions futures) \|
237	239
238	240		#### LoadN
239	241
240	242		\| Champ \| Description \|
241	243		\|----\|----\|
242	244		\| SymTableEntry: PSym; \| Entrée de table de symbole pour ce symbole \|
243	245		\| SymTable: PSymTable; \| Table de symbole dans lequel ce symbole est enregistré \|
244	246		\| Is_Absolute: Boolean; \| Mis à TRUE si cette variable est [[Absolute/fr\|absolute]]. \|
245	247		\| Is_First: Boolean; \| Mis à TRUE si c'est la première occurence du chargement de cette variable (utilisé avec variable varstate pour des optimisations) \|
246	248
247	249		#### CallN
248	250
249	251		\| Champ \| Description \|
250	252		\|----\|----\|
251	253		\| SymTableProcEntry: PProcSym; \| Entrée de table de symboles pour cette routine \|
252	254		\| SymTableProc: PSymTable; \| Table de symbole associé à un appel (table de symboles objet ou table de symboles de routine) \|
253	255		\| ProcDefinition: pAbstractProcDef; \| Définition de type pour cette routine \|
254	256		\| MethodPointer: pTree; \| ????????? \|
255	257		\| No_Check: Boolean; \| inutilisé actuellement \|
256	258		\| Unit_Specific: Boolean; \| Mis à TRUE si cette routine est importée d'une unité de manière spécifique (p.ex.: system.writeln()) \|
257	259		\| Return_Value_Used : Boolean \| Mis à TRUE si la routine est une fonction et que la vaelur retournée n'est pas utilisée (dans l'analyse de syntaxe étendue - \$X+) \|
258	260		\| Static_Call: Boolean; \| inutilisé \|
259	261
260	262		#### addrn
261	263
262	264		\| Champ \| Description \|
263	265		\|----\|----\|
264	266		\| ProcVarLoad: Boolean; \| Mis à TRUE si c'est un appel de variable procédurale \|
265	267
266	268		#### OrdConstN
267	269
268	270		\| Champ \| Description \|
269	271		\|-----------------\|-------------------------------------------\|
270	272		\| Value: LongInt; \| La valeur numérique de ce noeud constante \|
271	273
272	274		#### RealConstN
273	275
274	276		\| Champ \| Description \|
275	277		\|----\|----\|
276	278		\| Value_Real: Best_Real; \| La valeur numérique de ce noeud constante \|
277	279		\| Lab_Real: PAsmLabel; \| La référence d'étiquette Assembleur pour cette constante \|
278	280
279	281		#### FixConstN
280	282
281	283		\| Champ \| Description \|
282	284		\|---------------------\|-------------------------------------------\|
283	285		\| Value_Fix: LongInt; \| La valeur numérique de ce noeud constante \|
284	286
285	287		#### FuncRetN
286	288
287	289		\| Champ \| Description \|
288	290		\|----\|----\|
289	291		\| FuncRetProcInfo: Pointer; (PProcInfo) \| Pointeur vers l'information de procédure \|
290	292		\| RetType: TType; \| Indique le type de retour de la fonction \|
291	293		\| Is_First_FuncRet: Boolean; \| \|
292	294
293	295		#### SubscriptN
294	296
295	297		\| Champ \| Description \|
296	298		\|----\|----\|
297	299		\| vs: pVarSym; \| Entrée de table de symboles pour cette variable (un champ d'objet/de classe/d'enregistrement) \|
298	300
299	301		#### RaiseN
300	302
301	303		\| Champ \| Description \|
302	304		\|----\|----\|
303	305		\| FrameTree: PTree; \| Arbre du cadre d'exception (code dans l'instruction Raise) \|
304	306
305	307		#### VecN
306	308
307	309		\| Champ \| Description \|
308	310		\|----\|----\|
309	311		\| MemIndex: Boolean; \| Mis à TRUE si la directive Mem\[Seg:Ofs\] est analysée \|
310	312		\| MemSeg: Boolean; \| Mis à TRUE si la directive Mem\[Seg:Ofs\] est analysée \|
311	313		\| CallUnique: Boolean; \| \|
312	314
313	315		#### StringConstN
314	316
315	317		\| Champ \| Description \|
316	318		\|----\|----\|
317	319		\| Value_Str: PChar; \| La valeur constante de la chaîne \|
318	320		\| Length: LongInt; \| Longueur de la chaîne en octets (ou en caractères ?) \|
319	321		\| Lab_Str: PAsmLabel; \| La référence de l'étiquette assembleur de cette constante \|
320	322		\| StringType: TStringType; \| Le type de la chaîne (short, long, ansi, wide) \|
321	323
322	324		#### TypeConvN
323	325
324	326		\| Champ \| Description \|
325	327		\|----\|----\|
326	328		\| ConvType: TConvertType; \| Indique la conversion de type à réaliser \|
327	329		\| Explizit: Boolean; \| Mis à TRUE si cela était une conversion explicite (avec un typecast explicite, ou en appelant une des routines de conversion internes) \|
328	330
329	331		#### TypeN
330	332
331	333		\| Champ \| Description \|
332	334		\|------------------------\|-------------------------------------\|
333	335		\| TypeNodeType: PDef; \| La définition de type pour ce noeud \|
334	336		\| TypeNodeSym: PTypeSym; \| L'information de type du symbole \|
335	337
336	338		#### InlineN
337	339
338	340		\| Champ \| Description \|
339	341		\|----\|----\|
340	342		\| InlineNumber: Byte; \| Indique la routine interne appelée (Cf. générateur de code) \|
341	343		\| InlineConst: Boolean; \| Un ou plusieurs des paramètres pour cet appel de routine inline contient des valeurs constantes \|
342	344
343	345		#### ProcInlineN
344	346
345	347		Les noeuds inline sont créés quand une routine est déclarée comme étant inline. La routine est effectivement inline-ée quand les conditions suivantes sont satisfaites:
346	348
347	349		- C'est un appel à l'intérieur du même module
348	350
349	351		- Le commutateur approprié du compilateur est activé
350	352
351	353		- La routine n'est pas une méthode (i.e. c'est une procédure ou une fonction normale)
352	354
353	355		Sinon, un appel normal est fait, ignorant la directive inline. Dans le cas où la routine est inline-ée, tous les paramètres, valeurs de retour et variables locales de la routine inline sont effectivement alloués dans l'espace de la pile de la routine dans laquelle l'appel inline est fait (dite routine parent plus bas).
354	356
355	357		\| Champ \| Description \|
356	358		\|----\|----\|
357	359		\| InlineTree: PTree; \| L'arbre complet pour cette routine inline \|
358	360		\| InlineProcsym: PProcSym; \| Entrée de table de symboles pour cette routine \|
359	361		\| RetOffset: LongInt; \| Décalage du retour dans l'espace de la pile de la routine parent \|
360	362		\| Para_Offset: LongInt; \| Décalage du paramètre de départ dans l'espace de la pile de la routine parent \|
361	363		\| Para_Size: LongInt; \| Taille du paramètre dans l'espace de la pile de la routine parent \|
362	364
363	365		#### SetConstN
364	366
365	367		\| Champ \| Description \|
366	368		\|----\|----\|
367	369		\| Value_Set: PConstSet; \| La valeur numérique de ce noeud constante \|
368	370		\| Lab_Set: PAsmLabel; \| La référence de l'étiquette assembleur pour cette constante \|
369	371
370	372		#### LoopN
371	373
372	374		\| Champ \| Description \|
373	375		\|-------\|-------------\|
374	376		\| \| \|
375	377
376	378		#### AsmN
377	379
378	380		\| Champ \| Description \|
379	381		\|----\|----\|
380	382		\| p_Asm: PAasmOutput; \| L'arbre d'instruction créé par l'analyseur assembelur \|
381	383		\| Object_Preserved: Boolean; \| Mis à FALSE si le Self_Register a été modifié dans l'instruction asm \|
382	384
383	385		#### CaseN
384	386
385	387		\| Champ \| Description \|
386	388		\|----\|----\|
387	389		\| Nodes: PCaseRecord; \| Arbre de chaque alternative possible dans une instruction case \|
388	390		\| ElseBlock: PTree; \| Arbre du bloc d'instructions Else \|
389	391
390	392		#### LabelN, GotoN
391	393
392	394		\| Champ \| Description \|
393	395		\|------------------------\|--------------------------------------------------\|
394	396		\| LabelNr: PAsmLabel; \| Etiquette Assembleur associée avec l'instruction \|
395	397		\| ExceptionBlock: PTree; \| ? \|
396	398		\| LabSym: PLabelSym; \| Entrée de table de symboles pour cette étiquette \|
397	399
398	400		#### WithN
399	401
400	402		\| Champ \| Description \|
401	403		\|-------------------------------\|-------------\|
402	404		\| WithSymTables: PWithSymTable; \| \|
403	405		\| TableCount: LongInt; \| \|
404	406		\| WithReference: PReference; \| \|
405	407		\| IsLocal: Boolean; \| \|
406	408
407	409		#### OnN
408	410
409	411		\| Champ \| Description \|
410	412		\|----------------------------\|-------------\|
411	413		\| ExceptSymTable: PSymTable; \| \|
412	414		\| ExceptType: PObjectDef; \| \|
413	415
414	416		#### ArrayConstructorN
415	417
416	418		\| Champ \| Description \|
417	419		\|--------------------------\|-------------\|
418	420		\| CArgs: Boolean; \| \|
419	421		\| CArgSwap: Boolean; \| \|
420	422		\| ForceVaria: Boolean; \| \|
421	423		\| NoVariaAllowed: Boolean; \| \|
422	424		\| ConstructorDef: PDef; \| \|
423	425
424	426		Prochain chapitre: [[Symbol tables/fr\|Table des symboles]]
425	427
426	428		---
427	429		From the Free Pascal wiki, page "The parse tree/fr", as it stood on 2020-12-24 after a change by E-ric, 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