Merge branch 'linux'
[perl-ctypes:perl-ctypes.git] / include / const-c.inc
1 #define PERL_constant_NOTFOUND  1
2 #define PERL_constant_NOTDEF    2
3 #define PERL_constant_ISIV      3
4 #define PERL_constant_ISNO      4
5 #define PERL_constant_ISNV      5
6 #define PERL_constant_ISPV      6
7 #define PERL_constant_ISPVN     7
8 #define PERL_constant_ISSV      8
9 #define PERL_constant_ISUNDEF   9
10 #define PERL_constant_ISUV      10
11 #define PERL_constant_ISYES     11
12
13 #ifndef NVTYPE
14 typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it.  */
15 #endif
16 #ifndef aTHX_
17 #define aTHX_ /* 5.6 or later define this for threading support.  */
18 #endif
19 #ifndef pTHX_
20 #define pTHX_ /* 5.6 or later define this for threading support.  */
21 #endif
22
23 static int
24 constant_13 (pTHX_ const char *name, IV *iv_return) {
25   /* When generated this function returned values for the list of names given
26      here.  However, subsequent manual editing may have added or removed some.
27      FFI_TYPE_LAST FFI_TYPE_VOID ffi_type_sint ffi_type_uint */
28   /* Offset 9 gives the best switch position.  */
29   switch (name[9]) {
30   case 'L':
31     if (memEQ(name, "FFI_TYPE_LAST", 13)) {
32     /*                        ^          */
33 #ifdef FFI_TYPE_LAST
34       *iv_return = FFI_TYPE_LAST;
35       return PERL_constant_ISIV;
36 #else
37       return PERL_constant_NOTDEF;
38 #endif
39     }
40     break;
41   case 'V':
42     if (memEQ(name, "FFI_TYPE_VOID", 13)) {
43     /*                        ^          */
44 #ifdef FFI_TYPE_VOID
45       *iv_return = FFI_TYPE_VOID;
46       return PERL_constant_ISIV;
47 #else
48       return PERL_constant_NOTDEF;
49 #endif
50     }
51     break;
52   case 's':
53     if (memEQ(name, "ffi_type_sint", 13)) {
54     /*                        ^          */
55 #ifdef ffi_type_sint
56       *iv_return = ffi_type_sint;
57       return PERL_constant_ISIV;
58 #else
59       return PERL_constant_NOTDEF;
60 #endif
61     }
62     break;
63   case 'u':
64     if (memEQ(name, "ffi_type_uint", 13)) {
65     /*                        ^          */
66 #ifdef ffi_type_uint
67       *iv_return = ffi_type_uint;
68       return PERL_constant_ISIV;
69 #else
70       return PERL_constant_NOTDEF;
71 #endif
72     }
73     break;
74   }
75   return PERL_constant_NOTFOUND;
76 }
77
78 static int
79 constant_14 (pTHX_ const char *name, IV *iv_return) {
80   /* When generated this function returned values for the list of names given
81      here.  However, subsequent manual editing may have added or removed some.
82      FFI_SIZEOF_ARG FFI_TYPE_FLOAT FFI_TYPE_SINT8 FFI_TYPE_UINT8 ffi_type_schar
83      ffi_type_slong ffi_type_uchar ffi_type_ulong */
84   /* Offset 10 gives the best switch position.  */
85   switch (name[10]) {
86   case 'I':
87     if (memEQ(name, "FFI_TYPE_SINT8", 14)) {
88     /*                         ^          */
89 #ifdef FFI_TYPE_SINT8
90       *iv_return = FFI_TYPE_SINT8;
91       return PERL_constant_ISIV;
92 #else
93       return PERL_constant_NOTDEF;
94 #endif
95     }
96     if (memEQ(name, "FFI_TYPE_UINT8", 14)) {
97     /*                         ^          */
98 #ifdef FFI_TYPE_UINT8
99       *iv_return = FFI_TYPE_UINT8;
100       return PERL_constant_ISIV;
101 #else
102       return PERL_constant_NOTDEF;
103 #endif
104     }
105     break;
106   case 'L':
107     if (memEQ(name, "FFI_TYPE_FLOAT", 14)) {
108     /*                         ^          */
109 #ifdef FFI_TYPE_FLOAT
110       *iv_return = FFI_TYPE_FLOAT;
111       return PERL_constant_ISIV;
112 #else
113       return PERL_constant_NOTDEF;
114 #endif
115     }
116     break;
117   case '_':
118     if (memEQ(name, "FFI_SIZEOF_ARG", 14)) {
119     /*                         ^          */
120 #ifdef FFI_SIZEOF_ARG
121       *iv_return = FFI_SIZEOF_ARG;
122       return PERL_constant_ISIV;
123 #else
124       return PERL_constant_NOTDEF;
125 #endif
126     }
127     break;
128   case 'c':
129     if (memEQ(name, "ffi_type_schar", 14)) {
130     /*                         ^          */
131 #ifdef ffi_type_schar
132       *iv_return = ffi_type_schar;
133       return PERL_constant_ISIV;
134 #else
135       return PERL_constant_NOTDEF;
136 #endif
137     }
138     if (memEQ(name, "ffi_type_uchar", 14)) {
139     /*                         ^          */
140 #ifdef ffi_type_uchar
141       *iv_return = ffi_type_uchar;
142       return PERL_constant_ISIV;
143 #else
144       return PERL_constant_NOTDEF;
145 #endif
146     }
147     break;
148   case 'l':
149     if (memEQ(name, "ffi_type_slong", 14)) {
150     /*                         ^          */
151 #ifdef ffi_type_slong
152       *iv_return = ffi_type_slong;
153       return PERL_constant_ISIV;
154 #else
155       return PERL_constant_NOTDEF;
156 #endif
157     }
158     if (memEQ(name, "ffi_type_ulong", 14)) {
159     /*                         ^          */
160 #ifdef ffi_type_ulong
161       *iv_return = ffi_type_ulong;
162       return PERL_constant_ISIV;
163 #else
164       return PERL_constant_NOTDEF;
165 #endif
166     }
167     break;
168   }
169   return PERL_constant_NOTFOUND;
170 }
171
172 static int
173 constant_15 (pTHX_ const char *name, IV *iv_return) {
174   /* When generated this function returned values for the list of names given
175      here.  However, subsequent manual editing may have added or removed some.
176      FFI_BAD_TYPEDEF FFI_TYPE_DOUBLE FFI_TYPE_SINT16 FFI_TYPE_SINT32
177      FFI_TYPE_SINT64 FFI_TYPE_STRUCT FFI_TYPE_UINT16 FFI_TYPE_UINT32
178      FFI_TYPE_UINT64 ffi_type_sshort ffi_type_ushort */
179   /* Offset 13 gives the best switch position.  */
180   switch (name[13]) {
181   case '1':
182     if (memEQ(name, "FFI_TYPE_SINT16", 15)) {
183     /*                            ^        */
184 #ifdef FFI_TYPE_SINT16
185       *iv_return = FFI_TYPE_SINT16;
186       return PERL_constant_ISIV;
187 #else
188       return PERL_constant_NOTDEF;
189 #endif
190     }
191     if (memEQ(name, "FFI_TYPE_UINT16", 15)) {
192     /*                            ^        */
193 #ifdef FFI_TYPE_UINT16
194       *iv_return = FFI_TYPE_UINT16;
195       return PERL_constant_ISIV;
196 #else
197       return PERL_constant_NOTDEF;
198 #endif
199     }
200     break;
201   case '3':
202     if (memEQ(name, "FFI_TYPE_SINT32", 15)) {
203     /*                            ^        */
204 #ifdef FFI_TYPE_SINT32
205       *iv_return = FFI_TYPE_SINT32;
206       return PERL_constant_ISIV;
207 #else
208       return PERL_constant_NOTDEF;
209 #endif
210     }
211     if (memEQ(name, "FFI_TYPE_UINT32", 15)) {
212     /*                            ^        */
213 #ifdef FFI_TYPE_UINT32
214       *iv_return = FFI_TYPE_UINT32;
215       return PERL_constant_ISIV;
216 #else
217       return PERL_constant_NOTDEF;
218 #endif
219     }
220     break;
221   case '6':
222     if (memEQ(name, "FFI_TYPE_SINT64", 15)) {
223     /*                            ^        */
224 #ifdef FFI_TYPE_SINT64
225       *iv_return = FFI_TYPE_SINT64;
226       return PERL_constant_ISIV;
227 #else
228       return PERL_constant_NOTDEF;
229 #endif
230     }
231     if (memEQ(name, "FFI_TYPE_UINT64", 15)) {
232     /*                            ^        */
233 #ifdef FFI_TYPE_UINT64
234       *iv_return = FFI_TYPE_UINT64;
235       return PERL_constant_ISIV;
236 #else
237       return PERL_constant_NOTDEF;
238 #endif
239     }
240     break;
241   case 'C':
242     if (memEQ(name, "FFI_TYPE_STRUCT", 15)) {
243     /*                            ^        */
244 #ifdef FFI_TYPE_STRUCT
245       *iv_return = FFI_TYPE_STRUCT;
246       return PERL_constant_ISIV;
247 #else
248       return PERL_constant_NOTDEF;
249 #endif
250     }
251     break;
252   case 'E':
253     if (memEQ(name, "FFI_BAD_TYPEDEF", 15)) {
254     /*                            ^        */
255       *iv_return = FFI_BAD_TYPEDEF;
256       return PERL_constant_ISIV;
257     }
258     break;
259   case 'L':
260     if (memEQ(name, "FFI_TYPE_DOUBLE", 15)) {
261     /*                            ^        */
262 #ifdef FFI_TYPE_DOUBLE
263       *iv_return = FFI_TYPE_DOUBLE;
264       return PERL_constant_ISIV;
265 #else
266       return PERL_constant_NOTDEF;
267 #endif
268     }
269     break;
270   case 'r':
271     if (memEQ(name, "ffi_type_sshort", 15)) {
272     /*                            ^        */
273 #ifdef ffi_type_sshort
274       *iv_return = ffi_type_sshort;
275       return PERL_constant_ISIV;
276 #else
277       return PERL_constant_NOTDEF;
278 #endif
279     }
280     if (memEQ(name, "ffi_type_ushort", 15)) {
281     /*                            ^        */
282 #ifdef ffi_type_ushort
283       *iv_return = ffi_type_ushort;
284       return PERL_constant_ISIV;
285 #else
286       return PERL_constant_NOTDEF;
287 #endif
288     }
289     break;
290   }
291   return PERL_constant_NOTFOUND;
292 }
293
294 static int
295 constant_19 (pTHX_ const char *name, IV *iv_return) {
296   /* When generated this function returned values for the list of names given
297      here.  However, subsequent manual editing may have added or removed some.
298      FFI_SIZEOF_JAVA_RAW FFI_TYPE_LONGDOUBLE ffi_type_longdouble */
299   /* Offset 18 gives the best switch position.  */
300   switch (name[18]) {
301   case 'E':
302     if (memEQ(name, "FFI_TYPE_LONGDOUBL", 18)) {
303     /*                                 E      */
304 #ifdef FFI_TYPE_LONGDOUBLE
305       *iv_return = FFI_TYPE_LONGDOUBLE;
306       return PERL_constant_ISIV;
307 #else
308       return PERL_constant_NOTDEF;
309 #endif
310     }
311     break;
312   case 'W':
313     if (memEQ(name, "FFI_SIZEOF_JAVA_RA", 18)) {
314     /*                                 W      */
315 #ifdef FFI_SIZEOF_JAVA_RAW
316       *iv_return = FFI_SIZEOF_JAVA_RAW;
317       return PERL_constant_ISIV;
318 #else
319       return PERL_constant_NOTDEF;
320 #endif
321     }
322     break;
323   case 'e':
324     if (memEQ(name, "ffi_type_longdoubl", 18)) {
325     /*                                 e      */
326 #ifdef ffi_type_longdouble
327       *iv_return = ffi_type_longdouble;
328       return PERL_constant_ISIV;
329 #else
330       return PERL_constant_NOTDEF;
331 #endif
332     }
333     break;
334   }
335   return PERL_constant_NOTFOUND;
336 }
337
338 static int
339 constant (pTHX_ const char *name, STRLEN len, IV *iv_return) {
340   /* Initially switch on the length of the name.  */
341   /* When generated this function returned values for the list of names given
342      in this section of perl code.  Rather than manually editing these functions
343      to add or remove constants, which would result in this comment and section
344      of code becoming inaccurate, we recommend that you edit this section of
345      code, and use it to regenerate a new set of constant functions which you
346      then use to replace the originals.
347
348      Regenerate these constant functions by feeding this entire source file to
349      perl -x
350
351 #!C:\strawberry\perl\bin\perl.exe -w
352 use ExtUtils::Constant qw (constant_types C_constant XS_constant);
353
354 my $types = {map {($_, 1)} qw(IV)};
355 my @names = (qw(FFI_LONG_LONG_MAX FFI_SIZEOF_ARG FFI_SIZEOF_JAVA_RAW
356                FFI_TYPE_DOUBLE FFI_TYPE_FLOAT FFI_TYPE_INT FFI_TYPE_LAST
357                FFI_TYPE_LONGDOUBLE FFI_TYPE_POINTER FFI_TYPE_SINT16
358                FFI_TYPE_SINT32 FFI_TYPE_SINT64 FFI_TYPE_SINT8 FFI_TYPE_STRUCT
359                FFI_TYPE_UINT16 FFI_TYPE_UINT32 FFI_TYPE_UINT64 FFI_TYPE_UINT8
360                FFI_TYPE_VOID ffi_type_longdouble ffi_type_schar ffi_type_sint
361                ffi_type_slong ffi_type_sshort ffi_type_uchar ffi_type_uint
362                ffi_type_ulong ffi_type_ushort),
363             {name=>"FFI_BAD_ABI", type=>"IV", macro=>"1"},
364             {name=>"FFI_BAD_TYPEDEF", type=>"IV", macro=>"1"},
365             {name=>"FFI_OK", type=>"IV", macro=>"1"});
366
367 print constant_types(), "\n"; # macro defs
368 foreach (C_constant ("Ptypes2", 'constant', 'IV', $types, undef, 3, @names) ) {
369     print $_, "\n"; # C constant subs
370 }
371 print "\n#### XS Section:\n";
372 print XS_constant ("Ptypes2", $types);
373 __END__
374    */
375
376   switch (len) {
377   case 6:
378     if (memEQ(name, "FFI_OK", 6)) {
379       *iv_return = FFI_OK;
380       return PERL_constant_ISIV;
381     }
382     break;
383   case 11:
384     if (memEQ(name, "FFI_BAD_ABI", 11)) {
385       *iv_return = FFI_BAD_ABI;
386       return PERL_constant_ISIV;
387     }
388     break;
389   case 12:
390     if (memEQ(name, "FFI_TYPE_INT", 12)) {
391 #ifdef FFI_TYPE_INT
392       *iv_return = FFI_TYPE_INT;
393       return PERL_constant_ISIV;
394 #else
395       return PERL_constant_NOTDEF;
396 #endif
397     }
398     break;
399   case 13:
400     return constant_13 (aTHX_ name, iv_return);
401     break;
402   case 14:
403     return constant_14 (aTHX_ name, iv_return);
404     break;
405   case 15:
406     return constant_15 (aTHX_ name, iv_return);
407     break;
408   case 16:
409     if (memEQ(name, "FFI_TYPE_POINTER", 16)) {
410 #ifdef FFI_TYPE_POINTER
411       *iv_return = FFI_TYPE_POINTER;
412       return PERL_constant_ISIV;
413 #else
414       return PERL_constant_NOTDEF;
415 #endif
416     }
417     break;
418   case 17:
419     if (memEQ(name, "FFI_LONG_LONG_MAX", 17)) {
420 #ifdef FFI_LONG_LONG_MAX
421       *iv_return = FFI_LONG_LONG_MAX;
422       return PERL_constant_ISIV;
423 #else
424       return PERL_constant_NOTDEF;
425 #endif
426     }
427     break;
428   case 19:
429     return constant_19 (aTHX_ name, iv_return);
430     break;
431   }
432   return PERL_constant_NOTFOUND;
433 }
434