Type information/fr: what changed

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

Title: Type information/fr

New		Line
1	+	Retour au contenu [[FPC internals/fr\|FPC internals]]
2	+
3	+	# Information de Type
4	+
5	+	## Architecture
6	+
7	+	(Dernière mise à jour pour FPC version 1.0.x)
8	+
9	+	Une déclaration de type, qui est la base de la table de symboles, car par nature tout se résume à un type après analyse est une structure spéciale avec deux champs principaux, qui pointent vers une entrée de table de symboles qui est le nom du type, et la définition réelle qui donne les informations sur les autres symboles du type, la taille du type et d'autres informations similaires.
10	+
11	+	``` pascal
12	+	type
13	+	TType = object
14	+	Sym: PSym; // Points to the symbol table of this type
15	+	Def: PDef; // Points to the actual definition of this type
16	+	end;
17	+	```
18	+
19	+	## Types de définition
20	+
21	+	(Dernière mise à jour pour FPC version 1.0.x)
22	+
23	+	Les définitions représentent l'information de type pour tous les symboles possibles qui peuvent être rencontrés par l'analyseur. Les types de définition avec les symboles dans la table des symboles, et sont utilisés par le processus d'analyse (entre autres choses) pour réaliser le contrôle de type.
24	+
25	+	Les types de définition actuels possibles sont énumérés dans `TDefType` et peuvent avoir l'une des valeurs symboliques :
26	+
27	+	<http://www.pjh2.de/fpc/CompilerInternalsFigure07.png>
28	+
29	+	\| deftype d'objet TDef \| Description \|
30	+	\|----\|----\|
31	+	\| AbstractDef \| \|
32	+	\| ArrayDef \| Définition de type Tableau \|
33	+	\| RecordDef \| Définition de type Enregistrement \|
34	+	\| PointerDef \| Définition de type Pointeur \|
35	+	\| OrdDef \| Définition de type ordinal (valeur numérique) \|
36	+	\| StringDef \| Définition de type String \|
37	+	\| EnumDef \| Définition de type Enumération \|
38	+	\| ProcDef \| Définition de type Procédure \|
39	+	\| ObjectDef \| Définition de type Object ou classe \|
40	+	\| ErrorDef \| Définition d'erreur (vide, utilisé pour reprise d'erreur) \|
41	+	\| FileDef \| Définition de type Fichier \|
42	+	\| FormalDef \| \|
43	+	\| SetDef \| Définition de type Ensemble \|
44	+	\| ProcVarDef \| Définition de type variable procédurale \|
45	+	\| FloatDef \| Définition de type Virgule flottante \|
46	+	\| ClassrefDef \| \|
47	+	\| ForwardDef \| \|
48	+
49	+	### Définition de base (TDef)
50	+
51	+	Toutes les défintions de type sont basées sur cet classe. Par conséquent, tous les objets dérivés possèdent tous les champs de cet objet en plus de leurs propres champs privés.
52	+
53	+	``` pascal
54	+	type
55	+	PDef = ^TDef;
56	+	TDef = object(TSymTableEntry)
57	+	TypeSym: PTypeSym; // Pointer to symbol table entry for this type
58	+	// definition
59	+	InitTable_Label: PAsmLabel; // Label to initialization information (required
60	+	// for some complex types)
61	+	Rtti_Label: PAsmLabel; // Label to the runtime type information.
62	+	NextGlobal: PDef;
63	+	PreviousGlobal: PDef;
64	+	SaveSize: Longint; // Size in bytes of the data definition
65	+	DefType: TDefType; // Indicates the definition type (see table ??).
66	+	Has_InitTable: Boolean;
67	+	Has_Rtti: Boolean;
68	+	Is_Def_Stab_Written: TDefStabStatus; // Can be one of the following states :
69	+	// (Not_Written, written, Being_Written)
70	+	// which indicates if the debug information
71	+	// for this type has been defined or not.
72	+	GlobalNb: Longint; // Internal stabs debug information type signature
73	+	// (each type definition has a numeric
74	+	// signature).
75	+	end;
76	+	```
77	+
78	+	### Définition de fichier (TFileDef)
79	+
80	+	La définition de fichier ne peut se produire que dans de rares cas, lorsqu'un `file of type` est analysé, une définition de fichier de ce type sera créée. De plus, en interne, une définition d'un type de fichier Text et d'un type de fichier untyped est créée lors du chargement de l'unité centrale. Ces types sont toujours définis lors de la compilation d'une unité ou d'un programme.
81	+
82	+	``` pascal
83	+	type
84	+	PFileDef = ^TFileDef;
85	+	TFileDef = object(TDef)
86	+	FileTyp: TFileTyp; // Indicates what type of file definition it is
87	+	// (text, untyped or typed).
88	+	TypedFileType: TType; // In the case of a typed file definition,
89	+	// definition of the type of the file
90	+	end;
91	+	```
92	+
93	+	### Définition formelle (TFormalDef)
94	+
95	+	### Définition avancée (TForwardDef)
96	+
97	+	La définition avancée (forward) est créée, lorsqu'un type est déclaré avant qu'une définition réelle n'existe. C'est le cas lorsque, par exemple, `type PMyObject = TMyObject`, alors que `TMyObject` n'a pas encore été défini.
98	+
99	+	``` pascal
100	+	type
101	+	PForwardDef = ^TForwardDef;
102	+	TForwardDef = object(TDef)
103	+	toSymName: String; // The symbol name for this forward declaration
104	+	// (the actual real definition does not exist yet)
105	+	ForwardPos: TFilePosInfo; // Indicates file position where this forward
106	+	// definition was declared.
107	+	end;
108	+	```
109	+
110	+	### Définition d'erreur (TErrorDef)
111	+
112	+	Cette définition est réellement une entrée de définition vide. Quand l'analyseur rencontre une erreur lors de l'analyse d'une définition au lieu de ne rien mettre dans le type pour un symbole, il pose cette entrée. Cela évite les accès illégaux en mémoire plus tard dans l'analyse.
113	+
114	+	### Définition de pointeur (TPointerDef)
115	+
116	+	La définition de pointeur est utilisée pour distinguer entre différents types de pointeurs dans le compilateur et est créée à chaque construction d'analyse `typename` trouvée.
117	+
118	+	``` pascal
119	+	type
120	+	PPointerDef = ^TPointerDef;
121	+	TPointerDef = object(TDef)
122	+	Is_Far: Boolean; // Used to indicate if this is a far pointer or not
123	+	// (this flag is cpu-specific)
124	+	PointerType: TType; // This indicates to what type definition this pointer
125	+	// points to.
126	+	end;
127	+	```
128	+
129	+	### Définition d'objet (TObjectDef)
130	+
131	+	La définition d'objet est créée chaque fois qu'une déclaration d'objet est trouvée dans la déclaration de la section type.
132	+
133	+	``` pascal
134	+	type
135	+	PObjectDef = ^TObjectDef;
136	+	TObjectDef = object(TDef)
137	+	ChildOf: PObjectDef; // This is a pointer to the parent object
138	+	// definition. It is set to nil, if
139	+	// this object definition has no parent.
140	+	ObjName: PString; // This is the object name
141	+	SymTable: PSymTable; // This is a pointer to the symbol
142	+	// table entries within this object.
143	+	ObjectOptions: TObjectOptions; // The options for this object, see
144	+	// the following table for the possible
145	+	// options for the object.
146	+	VMT_Offset: Longint; // This is the offset from the start
147	+	// of the object image in memory
148	+	// where the virtual method table is
149	+	// located.
150	+	Writing_Class_Record_Stab: Boolean;
151	+	end;
152	+	```
153	+
154	+	\| Options d'objet (TObjectOptions) \| Description \|
155	+	\|----\|----\|
156	+	\| oo_is_class \| Ceci est déclaration de classe de styel Delphi, et not pas un Object de Turbo Pascal. \|
157	+	\| oo_is_forward \| Ce drapeau est défini pour indiquer que l'objet a été déclaré dans une section type, mais qu'il n'y pas encore d'implémentation. \|
158	+	\| oo_has_virtual \| Cet objet / classe contient des méthodes virtuelles \|
159	+	\| oo_has_private \| Cet objet / classe contient des champs ou méthodes privés \|
160	+	\| oo_has_protected \| Cet objet / classe contient des champs ou méthodes protégés \|
161	+	\| oo_has_constructor \| Cet objet / classe possède une méthode constructeur \|
162	+	\| oo_has_destructor \| Cet objet / classe possède une méthode destructeur \|
163	+	\| oo_has_vmt \| Cet objet / classe a une table de méthode virtuelle \|
164	+	\| oo_has_msgstr \| Cet objet / classe contient un ou plusieurs gestionnaires de message (string) \|
165	+	\| oo_has_msgint \| Cet objet / classe contient un ou plusieurs gestionnaires de message (int) \|
166	+	\| oo_has_abstract \| Cet objet / classe contient un ou plusieurs méthodes abstraites \|
167	+	\| oo_can_have_published \| La classe a de l'information de type à l'exécution (RTTI), i.e. vous pouvez publier des propriétés \|
168	+	\| oo_cpp_class \| l'objet / classe utilise une structure de classe compatible C++ \|
169	+	\| oo_interface \| Cette classe est une interface de style Delphi \|
170	+
171	+	### Définition de référence de classe (TClassRefDef)
172	+
173	+	### Définition de tableau (TArrayDef)
174	+
175	+	Cette définition est créée quand une déclaration de type tableau est analysée. Elle contient toute l'information nécessaire pour le contrôle de type du tableau et la génération de code.
176	+
177	+	``` pascal
178	+	type
179	+	PArrayDef = ^TArrayDef;
180	+	TArrayDef = object(TDef)
181	+	IsVariant: Boolean;
182	+	IsConstructor : Boolean;
183	+	RangeNr: Longint; // Label number associated with the index values
184	+	// when range checking is on
185	+	LowRange : Longint; // The lower index range of the array definition
186	+	HighRange : Longint; // The higher index range of the array definition
187	+	ElementType : TType; // The type information for the elements of the array
188	+	RangeType : TType; // The type information for the index ranges of the array
189	+	IsArrayofConst : Boolean;
190	+	end;
191	+	```
192	+
193	+	### Définition d'enregistrement (TRecordDef)
194	+
195	+	L'entrée de définition d'enregistrement est créée chaque fois qu'un enregistrement est analysé. Il contient la table de symboles des éléments dans l'enregistrement.
196	+
197	+	``` pascal
198	+	type
199	+	PRecordDef = ^TRecordDef;
200	+	TRecordDef = object(TDef)
201	+	SymTable: PSymTable; // This is a pointer to the symbol table entries within
202	+	// this record.
203	+	end;
204	+	```
205	+
206	+	### Définition d'ordinal (TOrdDef)
207	+
208	+	Cette définition de type est celle utilisée pour toutes les valeurs ordinales comme les Char, les octets et autres valeurs de type numérique entier. Certaines des définitions de type prédéfinies sont automatiquement créées et chargées quand le compilateur démarre. Les autres sont créées durant la compilation, lorsqu'elles sont déclarés.
209	+
210	+	``` pascal
211	+	type
212	+	POrdDef = ^TOrdDef;
213	+	TOrdDef = object(TDef)
214	+	Low: Longint; // The minimum value of this ordinal type
215	+	High: Longint; // The maximum value of this ordinal type
216	+	Typ: TBaseType; // The type of ordinal value
217	+	end;
218	+	```
219	+
220	+	\| Type ordinal de base (TBaseType) \| Description \|
221	+	\|----\|----\|
222	+	\| uauto \| Définition de type ordinal utilisateur \|
223	+	\| uvoid \| Représente une valeur de retour vide (void) ou un noeud \|
224	+	\| uchar \| Caractère ASCII \|
225	+	\| u8bit \| Valeur 8-bit non signée \|
226	+	\| u16bit \| Valeur 16-bit non signée \|
227	+	\| u32bit \| Valeur 32-bit non signée \|
228	+	\| s16bit \| Valeur 16-bit signée \|
229	+	\| s32bit \| Valeur 32-bit signée \|
230	+	\| bool8bit \| Valeur booléenne 8-bit \|
231	+	\| bool16bit \| Valeur booléenne 16-bit \|
232	+	\| bool32bit \| Valeur booléenne 32-bit \|
233	+	\| u64bit \| Valeur 64-bit non signée (non complètement supportée/testée) \|
234	+	\| s64bit \| Valeur 64-bit signée \|
235	+	\| uwidechar \| Actuellement non supporté et inutilisé \|
236	+
237	+	### Définition de flottant (TFloatDef)
238	+
239	+	Cette définition de type est celle utilisée pour toutes les valeurs en virgule flottante telles que SINGLE, DOUBLE. Certaines des définitions de type prédéfinies sont automatiquement créées et chargées lorsque le compilateur démarre.
240	+
241	+	``` pascal
242	+	type
243	+	PFloatDef = ^TFloatDef;
244	+	TFloatDef = object(TDef)
245	+	Typ: TFloatType; // The type of floating point value.
246	+	end;
247	+	```
248	+
249	+	\| Type de base de virgule flottante (TFloatType) \| Description \|
250	+	\|----\|----\|
251	+	\| s32real \| Valeur virgule flottante en simple précision IEEE \|
252	+	\| s64real \| Valeur virgule flottante en double précision IEEE \|
253	+	\| s80real \| Valeur virgule flottante étendue (spécifique à la CPU, en général mappé vers le type Double) \|
254	+	\| s64comp \| Valeur 63-bit signée, utilisant 1 bit pour l'indication de signe \|
255	+	\| f16bit \| Non supporté \|
256	+	\| f32bit \| Non supporté \|
257	+
258	+	### Définition de procédure abstraite (tabstractprocdef)
259	+
260	+	Ceci est la base de définitions de type Routine. Cet objet est abstrait, et ne peut pas être directement utilisé de manière utile. L'objet dérivé de cet objet est utilisé pour le processus réel d'analyse.
261	+
262	+	``` pascal
263	+	type
264	+	PAbstractProcDef = ^TAbstractProcDef;
265	+	TAbstractProcDef = object(TDef)
266	+	SymtableLevel: Byte;
267	+	Fpu_Used: Byte; // Number of floating point registers
268	+	// used in this routine
269	+	RetType: TType; // Type information for the return value
270	+	// (uvoid if it returns nothing)
271	+	ProcTypeOption: TProcTypeOption; // Indicates the type of routine it is.
272	+	ProcCallOptions: TProcCallOptions; // Indicates the calling convention
273	+	// of the routine.
274	+	ProcOptions: TProcOptions; // Indicates general procedure options.
275	+	Para: PLinkedList; // This is a linked list of parameters
276	+	// (pparaitem list)
277	+	end;
278	+	```
279	+
280	+	\| Options de Procédure (TProcTypeOption) \| Description \|
281	+	\|----\|----\|
282	+	\| poType_ProgInit \| La routine est le point d'entrée du programme (défini comme main dans le compilateur). \|
283	+	\| poType_UnitInit \| La routine est le code d'initialisation de l'unité (défini comme unité unitname_init dans le compilateur) \|
284	+	\| poType_UnitFinalize \| La routine est Routine est le code de sortie de l'unité (défini comme unitname_finalize dnas le compilateur) \|
285	+	\| poType_Constructor \| La routine est une constructeur d'objet ou de classe \|
286	+	\| poType_Destructor \| La routine est un destructeur d'objet ou de classe \|
287	+	\| poType_Operator \| La procédure est un opérateur \|
288	+
289	+	\| Options d'appel (TProcCallOptions) \| Description \|
290	+	\|----\|----\|
291	+	\| pocall_clearstack \| L'appelant de la routine nettoie la pile apreès le retour \|
292	+	\| pocall_leftright \| Envoyer les paramètres à la routine de gauche à droite \|
293	+	\| pocall_cdecl \| Le passage des paramètres est fait en utilisant le schéma d'alignement GCC, le passage des valeurs de paramètre est directement copié dans l'espace de la pile \|
294	+	\| pocall_register \| inutilisé (envoie les paramètres via les registres) \|
295	+	\| pocall_stdcall \| Le passage des paramètres est fait en utilisant le schéma d'alignement GCC, les registres standard GCC sont sauvegardés \|
296	+	\| pocall_safecall \| Les registres standard GCC sont sauvegardés \|
297	+	\| pocall_palmsssyscall \| Ceci est une macro spéciale syscall pour les systèmes embarqués \|
298	+	\| pocall_system \| inutilisé \|
299	+	\| pocall_inline \| La routine est une macro assemnbleur inline (et non un véritable appelnot a true call) \|
300	+	\| pocall_internproc \| Routine d'assistance (helper) du générateur de code de l'unité système \|
301	+	\| pocall_internconst \| Routine macro d'assistance (helper) du générateur de code de l'unité système \|
302	+
303	+	\| Options de routine (TProcOptions) \| Description \|
304	+	\|----\|----\|
305	+	\| po_classmethod \| Ceci est une méthode de classse \|
306	+	\| po_virtualmethod \| Ceci est une méthode virtuelle \|
307	+	\| po_abstractmethod \| Ceci est une méthode abstraite \|
308	+	\| po_staticmethod \| Ceci est une méthode statique \|
309	+	\| po_overridingmethod \| Ceci est une méthode surchargée (avec le drapeau po_virtual en général) \|
310	+	\| po_methodpointer \| Ceci est un pointeur de méthode (et non pas un pointeur de routine normal) \|
311	+	\| po_containsself \| self est passé explicitement comme paramètre de la méthode \|
312	+	\| po_interrupt \| Cette routine est un gestionnaire d'interruption \|
313	+	\| po_iocheck \| Le contrôle des E/S doit être fait après un appel à cette routine \|
314	+	\| po_assembler \| La routine est en assembleur \|
315	+	\| po_msgstr \| Méthode pour la gestion des messages string \|
316	+	\| po_msgint \| Méthode pour la gestion des messages Int \|
317	+	\| po_exports \| La routine a une directive d'export \|
318	+	\| po_external \| La routine est externe (dans un autre objet ou bibliotèque) \|
319	+	\| po_savestdregs \| Entrée de routine devrait sauver tous les registres utilisés par GCC \|
320	+	\| po_saveregisters \| L'entrée de routinedevrait sauver tous les registres \|
321	+	\| po_overload \| La routine est declarée comme surchargée \|
322	+
323	+	### Définition de variable procédurale (TProcVarDef)
324	+
325	+	Cette défintion est créée quand un type de variable procédurale est déclaré. Il donne de l'information sur le type de la procédure et est utilisé lors de l'affectation et appelle directement une routine à travers un pointeur.
326	+
327	+	``` pascal
328	+	type
329	+	PProcVarDef = ^TProcVarDef;
330	+	TProcVarDef = object(TAbstractProcDef)
331	+	end;
332	+	```
333	+
334	+	### Définition de procédure (TProcDef)
335	+
336	+	Quand une tête (head) de procédure est analysée, la définition de la routine est créée. Par la suite, d'autres champs contenant de l'information sur la définition de la routine sopnt renseignées comme nécessaires.
337	+
338	+	``` pascal
339	+	type
340	+	PProcDef = ^TProcDef;
341	+	TProcDef = object(TAbstractProcDef)
342	+	ForwardDef: Boolean; // TRUE if this is a forward definition
343	+	InterfaceDef: Boolean;
344	+	ExtNumber: Longint;
345	+	MessageInf: TMessageInf;
346	+	NextOverloaded: PProcDef;
347	+	FileInfo: TFilePosInfo; // Position in source code for the declaration of
348	+	// this routine. Used for error management.
349	+	Localst: PSymTable; // The local variables symbol table
350	+	Parast: PSymTable; // The parameter symbol table
351	+	ProcSym: PProcSym; // Points to owner of this definition
352	+	LastRef: PRef;
353	+	DefRef: PRef;
354	+	CrossRef: PRef;
355	+	LastWritten: PRef;
356	+	RefCount: Longint;
357	+	_Class: ProbjectDef;
358	+	Code: Pointer; // The actual code for the routine
359	+	// (only for inlined routines)
360	+	UsedRegisters: TRegisterSet; // The set of registers used in this routine
361	+	HasForward: Boolean;
362	+	Count: Boolean;
363	+	Is_Used: Boolean;
364	+	end;
365	+	```
366	+
367	+	### Définition de chaîne de caractère (TStringDef)
368	+
369	+	Cette définition représente toutes les chaînes autant que les types dérivés. Certaines de ces définitions de type de chaîne par défaut sont chargées au démarrage du compilateur. D'autres sont créées au moment de la compilation car ils sont déclarés avec un type de longueur spécifique.
370	+
371	+	``` pascal
372	+	type
373	+	PStringDef = ^TStringDef;
374	+	TStringDef = object(TDef)
375	+	String_Typ: TStringType; // Indicates the string type definition
376	+	Len: Longint; // This is the maximum length which can have the string
377	+	end;
378	+	```
379	+
380	+	\| Type String (TStringType) \| Description \|
381	+	\|----\|----\|
382	+	\| st_default \| Selon les commutateurs (switches) courants du compilateur, peut être soit une st_ShortString ou une st_AnsiString \|
383	+	\| st_shortstring \| Chaîne courte (octet de longueur suivi par les caractères réels (1 octet/car.)) \|
384	+	\| st_longstring \| Chaîne longue (LongInt de longueur suivi par les caractères réels (1 octet/car.)) \|
385	+	\| st_ansistring \| Chaîne longue avec ramassage des miettes (garbage collected) (pointeur vers une longueur, un compteur de références suivi par les caractères ASCII réels (1 octet/car.)) \|
386	+	\| st_widestring \| Chaîne longue avec ramassage des miettes (pointeur vers une longueur, un compteur de références suivi par les caractères unicode réels (1 mot/car. (utf16))) \|
387	+
388	+	### Définition d'énumération (TEnumDef)
389	+
390	+	Une définition d'énumération est créée chaque fois qu'une énumération est déclarée et analysée. Chaque élément dans l'énumération sera ajoutée à la symtable de l'énumération et si la directive \$SCOPEDENUMS est off alors à la symtable de l'unité aussi.
391	+
392	+	``` pascal
393	+	type
394	+	tenumdef = class(tstoreddef)
395	+	has_jumps: Boolean; // True if enum has jumps between elements
396	+	minval: aint; // Value of the first element in the enumeration
397	+	maxval: aint; // Value of the last element in the enumeration
398	+	BaseDef: tenumdef; // In the case where the enumeration is a
399	+	// subrange of another enumeration or a unique
400	+	// enumeration copied from the another, this gives
401	+	// information on the base range of the elements
402	+	symtable: TSymtable; // Enumeration symbol table - stores enumeration elements
403	+	end;
404	+	```
405	+
406	+	### Définition d'ensemble (TSetDef)
407	+
408	+	Cette définition est créée quand une construction de type Ensemble est analysée (déclaration set of).
409	+
410	+	``` pascal
411	+	type
412	+	PSetDef = ^TSetDef;
413	+	TSetDef = object(TDef)
414	+	SetType: TSetType; Indicates the storage type of the set.
415	+	ElementType: TType; Points the type definition and symbol
416	+	table to the elements in the set.
417	+	end;
418	+	```
419	+
420	+	\| Type d'ensemble (TSetType) \| Description \|
421	+	\|----\|----\|
422	+	\| NormSet \| Ensemble normal de jusqu'à 256 éléments (espace de stockage de 32 octets requis) \|
423	+	\| SmallSet \| Petit ensemble jusquà 32 éléments (espace de stockage de 4 octets) \|
424	+	\| VarSet \| Ensemble avec un nombre variable d'éléments (Taille de stockage dépend du nombre d'éléments) (actuellement inutilisé et non supporté) \|
425	+
426	+	## Définition d'interface
427	+
428	+	((Dernière mise à jour pour FPC version 1.0.x)
429	+
430	+	### Routines
431	+
432	+	#### TDef.Size
433	+
434	+	\| \| \|
435	+	\|----\|----\|
436	+	\| Déclaration: \| `function`` TDef.Size: Longint;` \|
437	+	\| Description: \| Cette méthode retourne la vraie taille de l'espace mémoire requis en octets pour cette définition de type (après les considérations d'alignement). \|
438	+
439	+	#### TDef.Alignment
440	+
441	+	\| \| \|
442	+	\|----\|----\|
443	+	\| Déclaration: \| `function`` TDef.Alignment: Longint;` \|
444	+	\| Description: \| Cette méthode retourne l'alignement des données pour des types complexes tels que des enregistrements et objets, autrement elle retourne 0 ou 1 (pas d'alignement). \|
445	+
446	+	Prochain chapitre: [[The parser/fr\|L'analyseur]]
447	+
448	+	---
449	+	From the Free Pascal wiki, page "Type information/fr", as it stood on 2020-12-31 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