Common problems when converting C header files/fr: what changed

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

Old	New		Line
1	1		# h2pas rapporte une erreur
2	2
3	3		Voilà une liste des structures C courantes qui ne sont pas reconnues par h2pas et comment les corriger: (NdT: les titres ne sont pas traduits pour correspondre au message de l'outil)
4	4
5	5		## Problème h2pas : extern "C"
6	6
7	7		Certains fichiers d'entête contiennent le bloc espace de nom de C++:
8	8
9	9		``` c
10	10		#if defined(__cplusplus)
11	11		extern "C" {
12	12		#endif
13	13		...
14	14		#if defined(__cplusplus)
15	15		}
16	16		#endif
17	17		```
18	18
19	19		Correction: Ajouter les lignes Supprimer les lignes 'extern "C" ' de C++ dans les outils de la page Avant h2pas.
20	20
21	21		## Problème h2pas : Empty macro
22	22
23	23		Certains fichiers d'en-tête contiennent des macros vides utilisées pour d'autres extensions:
24	24
25	25		``` c
26	26		#define MPI_FILE_DEFINED
27	27		```
28	28
29	29		Correction: Ajouter la ligne Remove empty C macros dans les outils de la page Avant h2pas.
30	30
31	31		## Problème h2pas : Implicit array types
32	32
33	33		C autorise des tableaux implicites dans les types de paramètre. Par exemple:
34	34
35	35		``` c
36	36		int MPI_Group_range_incl(MPI_Group, int, int [][3], MPI_Group *);
37	37		```
38	38
39	39		int \[\]\[3\] est un type implicit, qui n'est pas permis dans Pascal. h2pas supporte l'ajout de types de pointer. Ainsi, il suffit de remplacer tous les \[\] avec *.
40	40
41	41		Correction: Ajouter la ligne Remplacer \[\] par * dans les outils de la page Avant h2pas.
42	42
43	43		## Problème h2pas : Macros for 0 pointers
44	44
45	45		Certains fichiers d'entête contiennent de pointeurs typés 0:
46	46
47	47		``` c
48	48		#define MPI_BOTTOM (void *)0
49	49		```
50	50
51	51		Correction: Ajouter la ligne *Replace macro values 0 pointer like (char )0 with NULL dans les outils de la page Avant h2pas**.
52	52
53	53		## Problème h2pas : function types are silently skipped
54	54
55	55		C permet de définir des types de fonctions, alros que Pascal ne permet que des pointeurs vers des fonctions (NdT: point à vérifier, Free Pascal supporte les types procéduraux). Par exemple:
56	56
57	57		``` c
58	58		typedef int (MPI_Comm_copy_attr_function)(MPI_Comm, int, void , void ,
59	59		void , int );
60	60		```
61	61
62	62		Le fichier d'entête n'utilise jamais cette définition directement, au lieu de cela, il utilise toujours des pointeurs de tels types MPI_Comm_copy_attr_function*, par exemple :
63	63
64	64		``` c
65	65		#define MPI_COMM_NULL_COPY_FN ((MPI_Comm_copy_attr_function*)0)
66	66		```
67	67
68	68		La traduction peut fonctionner en procédant ainsi: faire du type de fonction un pointeur. Ce qui signifie d'ajouter un * devant la définition et de faire précéder par un P le nom et de retirer le * après chaque référence. Par exemple:
69	69
70	70		``` c
71	71		typedef int (PMPI_Comm_copy_attr_function)(MPI_Comm, int, void , void *,
72	72		void , int );
73	73		#define MPI_COMM_NULL_COPY_FN ((PMPI_Comm_copy_attr_function)0)
74	74		```
75	75
76	76		Solution: Ajouter l'outil Convertir les types de fonction en pointeurs dans les outils de la page Avant h2pas.
77	77
78	78		# Compilation de test et ajouter des outils pour embellir la sortie
79	79
80	80		Lorsque h2pas s'exécute sans erreur, il a créé un fichier Pascal. Le commutateur -i définit s'il s'agit d'une unité ou d'un fichier d'inclusion. La prochaine étape est le test de compilation. Préparez un projet de test qui utilise le nouveau source Pascal. Ensuite utilisez le bouton Exécuter H2Pas et compiler dans l'assistant h2pas.
81	81
82	82		### Exemple: MPICH2
83	83
84	84		Créer un nouveau projet avec Projet -\> Nouveau Projet -\> Programme. Enregistrez-le dans mpihelloworld. Modifiez le code:
85	85
86	86		``` pascal
87	87		program MPIHelloWorld;
88	88
89	89		{$mode objfpc}{$H+}
90	90		{$linklib mpich}
91	91		{$linklib rt}
92	92
93	93		uses
94	94		{$IFDEF UNIX}pthreads{$ENDIF}, MPI;
95	95
96	96		begin
97	97		MPI_Init(@argc, @argv);
98	98		writeln('Hello, world.');
99	99		MPI_Finalize;
100	100		end.
101	101		```
102	102
103	103		Ajoutez le h2p/mpi.pas au projet. Projet -\> Ajouter le fichier de l'éditeur au projet
104	104
105	105		# Erreurs courantes du compilateur dans la sortie h2pas
106	106
107	107		Parfois, h2pas ne produit pas du code Pascal valide. Voici les problèmes courants et comment les résoudre.
108	108
109	109		## Unit name contains the file path
110	110
111	111		Parfois h2pas ajoute le chemin complet au nom d'unité.
112	112
113	113		Résolution: Ajouter Remplacement de "unit filename;" par "unit name;" dans les outils de la page Avant h2pas.
114	114
115	115		## Missing include files
116	116
117	117		h2pas convertit les directives \#include en directives pascal {\$i }. Si vous créez une unité pour chaque fichier d'entête C alors vopus pouvez retirer toutes les directives avec l'outil Suppression des directives incluses.
118	118
119	119		## Forward type not resolved
120	120
121	121		Par exemple mpi.pas(26,16) Error: Forward type not resolved "PMPI_Aint" La ligne d'erreur est souvent sur un type pointeur vers un enregistrement:
122	122
123	123		``` pascal
124	124		PMPI_Aint = ^MPI_Aint;
125	125		```
126	126
127	127		h2pas ajoute PMPI_Aint pour donner un nom au pointeurs C anonymes comme MPI_Aint. Il ajoute les pointeurs au début du fichier. Mais Pascal exige que la définition soit une section de même type*.
128	128
129	129		Parfois h2pas ajoute un type pointer alors qu'il existe déjà.
130	130
131	131		Résolution: Ajouter Supprimer les types de pointeurs redéfinis dans les outils Après h2pas.
132	132
133	133		## Removing system types
134	134
135	135		h2pas ajoute quelques types système, comme PLongint, qui font désormais partie de l'unité System.
136	136
137	137		Résolution: Ajouter l'outil Supprimer les redéfinitions de type comme "PLongint" aux outils Après h2pas.
138	138
139	139		## Empty type/var/const sections
140	140
141	141		Après que les outills du dessus aient enlevé quelques variables, types, constantes, des sections deviennent vides, ce qui n'est pas permis en Pascal.
142	142
143	143		Correction: Ajouter Remove empty type/var/const sections ou l'outil Post H2Pas aux outils After h2pas.
144	144
145	145		## h2pas forgets to add IFDEFs for function bodies
146	146
147	147		h2pas convertit les macros en functions. Mais la macro était dans un block IFDEF, h2pas n'ajoute pas les IFDEFs autour de la fonction.
148	148
149	149		Correction: Ajouter l'outil Add missing h2pas IFDEFs for function bodies ou le Post H2Pas. Ajoutez ceci juste devant l'outil Reduce compiler directives in pascal file.
150	150
151	151		## Implicit Types
152	152
153	153		C permet les paramètres de types implicites, par exemple, int \[\]\[3\]. Pascal ne le permet pas, donc vous devez lui donner un nom et déclarer un type. Mais h2pas ne le fait pas automatiquement et ajoute le type implicite à la place dans une syntaxe quasi-Pascal. Par exemple:
154	154
155	155		``` c
156	156		int some_func(int [][3]);
157	157		```
158	158
159	159		devient
160	160
161	161		``` pascal
162	162		function some_func(_para1:array[0..2] of Plongint):longint;cdecl;external;
163	163		```
164	164
165	165		Correction: Heureusement, il y a maintenant un outil pour supprimer les types implicites, c'est appelé Replace implicit types. Cela fait aussi partie de l'outil Post H2Pas. Ajoutez-le dans la liste des outiles after.
166	166
167	167		## Array of nothing
168	168
169	169		Parfois h2pas convertit le type paramètre à ellipse du C '...' incorrectement en 'array of )', il devrait être convertit en 'array of const)'. Sometimes h2pas converts the C ellipsis parameter type '...' wrongly to 'array of )'. It should be 'array of const)'.
170	170
171	171		## Identifier not found
172	172
173	173		Il y a quatre cas:
174	174
175	175		- The identifier is defined in the unit, but after it is used L'identificateur est défini mais après été utilisé.
176	176		- The identifier is defined in another unit (another .h file) L'identificateur est défini dnas une autre unité.
177	177		- The identifier is a pointer to an existing type, but h2pas forgot to add it L'identificateur est un pointeur sur un type existant mais h2pas a oublié de l'ajouter.
178	178		- The identifier is not defined anywhere L'identificateur n'est défini nulle part.
179	179
180	180		### The identifier is defined in the unit, but after it is used
181	181
182	182		En Pascal les types déclarés en avance sont uniquement permis dans une même section type. Par exemple:
183	183
184	184		``` pascal
185	185		type
186	186		TMyRecord = record
187	187		Next: PMyRecord; // utilisation de la déclaration avancée
188	188		end;
189	189		PMyRecord = ^TMyRecord;
190	190		```
191	191
192	192		Ce qui suit n'est pas permis, parce que la déclaration avancée est dans une autre section type
193	193
194	194		``` pascal
195	195		type
196	196		TMyRecord = record
197	197		Next: PMyRecord; // utilisation de la déclaration avancée
198	198		end;
199	199		type
200	200		PMyRecord = ^TMyRecord;
201	201		```
202	202
203	203		Solution: Le code doit être réordonné. Ajouter l'outil ''Corriger les déclarations avancées.
204	204
205	205		### The identifier is defined in another unit (another .h file)
206	206
207	207		#### Solution 1: Ajouter l'unité dans la section uses
208	208
209	209		Si l'autre unité utilis déjà cette unité, alors vous avez un cycle. Les dépendances circulaires sont permises entre fichier .h, mais pas dans les unité Pascal. Dans ce cas, vous devez déplacer le codes entre les deux unités ou utiliser des IFDEFs comme dans les liaisons gtk2 ou utiliser la fonction de fusion de l'assistant h2pas.
210	210
211	211		#### Solution 2: Fusionner les deux fichiers d'inclusion
212	212
213	213		L'assistant h2pas peut fusionner des fichiers d'inclusion en un seul. Par exemple, first.h inclut via la directive d'inclusion C le fichier second.h. Sélectionner le second.h dans l'assistant et contrôler la fonctionnalité 'Merge file'. Par la suite, le source de second.h sera ajouté à first.h avant d'envoyer le sortie vers h2pas. Comme toujours, cela ne change pas les fichiers d'entêtes.
214	214
215	215		#### Exemple: MPICH2
216	216
217	217		Le type MPI_Request est défini dans mpi.h et utilisé dans mpio.h. Les deux fichiers d'en-tête c s'utilisent fortement l'un l'autre, vous ne pouvez donc pas les mettre dans deux unités séparées. Sélectionnez mpio.h et activez la fonction 'Merge file'.
218	218
219	219		### The identifier is a pointer to an existing type, but h2pas forgot to add it
220	220
221	221		Solution: Add the tool Add missing pointer types like PPPChar or the Post H2Pas tool to the after H2Pas tools.
222	222
223	223		### The identifier is not defined anywhere
224	224
225	225		Probably you are missing a header file or you are using one with the wrong version or it is private identifier.
226	226
227	227		Solution: Search the header file and convert it too. If you can not find it or you don't want to translate this file, you can comment the identifier or replace it.
228	228
229	229		### Exemple: MPICH2
230	230
231	231		Note: this is just a demonstration. The real solution for the MPICH2 headers is to setup the Defines correct, so that the below example vanishes automatically.
232	232
233	233		The mpi.h file defines MPI_File as pointer of ADIOI_FileD, but ADIOI_FileD is not defined public:
234	234
235	235		``` c
236	236		typedef struct ADIOI_FileD *MPI_File;
237	237		```
238	238
239	239		The h2pas tool translated this to:
240	240
241	241		``` pascal
242	242		MPI_File = ^ADIOI_FileD;
243	243		```
244	244
245	245		Because ADIOI_FileD is not defined public, it is a private structure, so you can simply replace it with a Pointer: Add to the 'After h2pas' tools a new tool of type 'Search and replace' with the following properties:
246	246
247	247		\| Propriété \| Valeur \|
248	248		\|-------------\|----------------------------------\|
249	249		\| Caption \| Replace ADIOI_FileD with Pointer \|
250	250		\| Name \| ReplaceADIOI_FileDwithPointer \|
251	251		\| SearchFor \| ADIOI_FileD \|
252	252		\| ReplaceWith \| Pointer \|
253	253		\| Options \| \[trtMatchCase,trtWholeWord\] \|
254	254
255	255		## Illegal expression
256	256
257	257		### Exemple: MPICH2
258	258
259	259		Compiler gives Illegal expression on the following statement
260	260
261	261		``` pascal
262	262		const
263	263		MPI_LONG_LONG = MPI_LONG_LONG_INT;
264	264		```
265	265
266	266		The reason is, that h2pas translated the MPI_LONG_LONG_INT constant to a function.
267	267
268	268		Solution: Fix h2pas or use a trick:
269	269
270	270		Replace the
271	271
272	272		``` c
273	273		#define MPI_LONG_LONG MPI_LONG_LONG_INT
274	274		```
275	275
276	276		with
277	277
278	278		``` c
279	279		#define MPI_LONG_LONG ((MPI_Datatype)0x4c000809)
280	280		```
281	281
282	282		by adding a Search and replace tool before h2pas.
283	283
284	284		# Autres problèmes courants
285	285
286	286		## The pascal file contains a lot of unneccessary ifdef
287	287
288	288		h2pas translates even the C \#ifdef directives. Many of them are C specific and not needed under FPC and can even make it impossible many tools on this side to explore the code. That's why there is a tool to clean up and disable or remove many unneeded IFDEFs: Reduce compiler directives in pascal file. Do not forget to insert the tool Add missing h2pas IFDEFs for function bodies in front of it.
289	289
290	290		### Hints about unneeded directives (\$IFDEFs, \$DEFINEs, ...)
291	291
292	292		You can see the directives in the [[IDE Window: Code Explorer\|Code Explorer]].
293	293
294	294		The tool will only remove the \$IFDEFs and \$DEFINEs, that are unneeded on all platforms. That means for example a {\$IFDEF CPU386} will not be removed - even if you are currently working on an intel 32 bit compatible machine it will not be removed. This allows to create platform independent bindings. Of course C headers often contain a lot of IFDEFs not needed under FPC (Delphi, Kylix, gpc, ...).
295	295
296	296		For example: Many C headers are enclosed in
297	297
298	298		``` pascal
299	299		{$IFNDEF FOO}
300	300		{$DEFINE FOO}
301	301		...
302	302		{$ENDIF}
303	303		```
304	304
305	305		This trick allows to include a C header file multiple times - like the units under pascal. So, pascal does not need this. Therefore the tool Reduce compiler directives in pascal file and the Post H2Pas tool have two properties: Defines and Undefines. Click on the ... button of the property to edit them. Each line can contain a macroname, that should be (un)defined. Add the line FOO to the Undefines. This way the \$IFNDEF FOO is always true and the tool will remove it. The \$DEFINE FOO is now unneeded too and will be removed too.
306	306
307	307		#### Exemple: MPICH2
308	308
309	309		Add the following to the Undefines property:
310	310
311		-	~~` MPI_INCLUDED`\~~
312		-	~~` MPIO_INCLUDE`\~~
313		-	~~` NEEDS_MPI_FINT`\~~
314		-	~~` MPI_BUILD_PROFILING`\~~
315		-	~~` MPICH_SUPPRESS_PROTOTYPES`\~~
316		-	~~` MPI_Wtime`\~~
317		-	~~` HAVE_MPICH2G2`\~~
318		-	~~` FOO`\~~
319		-	~~` HAVE_PRAGMA_HP_SEC_DEF`~~
	311	+	```text
	312	+	MPI_INCLUDED
	313	+	MPIO_INCLUDE
	314	+	NEEDS_MPI_FINT
	315	+	MPI_BUILD_PROFILING
	316	+	MPICH_SUPPRESS_PROTOTYPES
	317	+	MPI_Wtime
	318	+	HAVE_MPICH2G2
	319	+	FOO
	320	+	HAVE_PRAGMA_HP_SEC_DEF
	321	+	```
320	322
321	323		Add the following to the Defines property:
322	324
323		-	~~` MPICH2`\~~
324		-	~~` MPICH_NEW_MPIIO`~~
	325	+	```text
	326	+	MPICH2
	327	+	MPICH_NEW_MPIIO
	328	+	```
325	329
326	330		## The C header files contain redefinitions
327	331
328	332		This is ok for C compilers, because a type is the same if its definition is the same. But for Pascal each type is a different type.
329	333
330	334		Solution: Add the tool Remove redefinitions in pascal unit or the Post H2Pas to the after h2pas tools. As the name implies, it only works on units, not on include files. And it expect at least a valid pascal syntax. That's why it is important to add this tool after the tools that fix the pascal syntax like Replace "unit filename;" with "unit name;", Remove empty type/var/const sections, Remove includes, Replace implicit types and Fix open arrays.
331	335
332	336		### Exemple: MPICH2
333	337
334	338		The mpi.h contains several redefinitions like MPIIMPL_HAVE_MPI_TYPE_CREATE_DARRAY. They can all be fixed with this tool.
335	339
336	340		## Alias macros are always translated by h2pas to constants
337	341
338	342		h2pas converts macros like
339	343
340	344		``` c
341	345		#define A B
342	346		```
343	347
344	348		to
345	349
346	350		``` pascal
347	351		const A = B;
348	352		```
349	353
350	354		which is almost always correct. But some c header contain aliases for types, variables and functions too.
351	355
352	356		### Example: MPICH2
353	357
354	358		The mpi.h contains the macro
355	359
356	360		``` c
357	361		#define MPI_LONG_LONG MPI_LONG_LONG_INT
358	362		```
359	363
360	364		h2pas converts this simply to
361	365
362	366		``` pascal
363	367		const
364	368		MPI_LONG_LONG = MPI_LONG_LONG_INT;
365	369		```
366	370
367	371		but MPI_LONG_LONG_INT is a function.
368	372
369	373		Solution: Add the tool Fixes section type of alias definitions in pascal unit or the Pre H2Pas tool to the Before H2Pas tools.
370	374
371	375		Note: This tool can also fix alias to external functions. For example:
372	376
373	377		``` pascal
374	378		function ExternalFunc1(_para1:longint; _para2:pointer):longint;cdecl;external name 'ExternalFunc1';
375	379		const
376	380		ExternalFuncAlias1 = ExternalFunc1;// should be replaced with full declaration
377	381		```
378	382
379	383		## h2pas creates functions for constants
380	384
381	385		Par exemple:
382	386
383	387		``` pascal
384	388		function MPI_2COMPLEX : MPI_Datatype;
385	389		begin
386	390		MPI_2COMPLEX:=MPI_Datatype(MPI_DATATYPE_NULL);
387	391		end;
388	392		```
389	393
390	394		All used identifiers are types and constants, so this function can be replaced with a simple constant. This is checked and done by the tool Replace simple functions with constants or the Post H2Pas.
391	395
392	396		## h2pas creates functions for type casts
393	397
394	398		Par exemple:
395	399
396	400		``` pascal
397	401		function PMPI_Win_f2c(win : longint) : MPI_Win;
398	402		begin
399	403		PMPI_Win_f2c:=MPI_Win(win);
400	404		end;
401	405		```
402	406
403	407		This function can be replaced with a simple type, resulting in a type cast. This is checked and done by the tool Replace simple functions with type casts or the Post H2Pas tool.
404	408
405	409		## Some identifiers are used before they are defined
406	410
407	411		C allows much more forward definitions than pascal, so the definitions must be topologically sorted. For example:
408	412
409	413		``` pascal
410	414		type
411	415		PMPI_Datatype = ^MPI_Datatype;
412	416		MPI_Datatype = longint;
413	417		```
414	418
415	419		The pointer PMPI_Datatype must be moved to the same type section as MPI_Datatype.
416	420
417	421		Solution: Add the Fix forward definitions by reordering or the Pre H2Pas tool to the Before H2Pas tools. The tool should be put after the tools fixing redefinitions and types. At the moment the tool only moves pointer types. ToDo: reorder some more definitions like constants.
418	422
419	423		## The C header files do not contain parameter names
420	424
421	425		For example there is an ugly function without parameter names:
422	426
423	427		``` c
424	428		int MPI_Intercomm_create(MPI_Comm, int, MPI_Comm, int, int, MPI_Comm * );
425	429		```
426	430
427	431		The parameter names are defined in the corresponding .c file:
428	432
429	433		``` c
430	434		int MPI_Intercomm_create(MPI_Comm local_comm, int local_leader,
431	435		MPI_Comm peer_comm, int remote_leader, int tag,
432	436		MPI_Comm *newintercomm)
433	437		```
434	438
435	439		Solution: There is no solution yet. Except manual editing or searching for other .h files. Often such .h files were auto generated and there are some nicer header files somewhere on the internet.
436	440
437	441		Proposal: Write a clever tool, that searches functions with missing parameter names and the corresponding functions in the .c files with parameter names and improve the .h file.
438	442
439	443		## Voir aussi
440	444
441	445		- [[Creating bindings for C libraries/fr\|Création de liaisons pour des bibliothèques C]]
442	446		- [[Pascal for C users/fr\|Pascal pour les utilisateurs du C]]
443	447		- [[Pascal for C++ users/fr\|Pascal pour les utilisateurs du C++]]
444	448		- [[SWIG/fr\|SWIG]]
445	449
446	450		---
447	451		From the Free Pascal wiki, page "Common problems when converting C header files/fr", as it stood on 2023-03-21 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