Google Git
Sign in
boringssl / boringssl / 6ccf29012c4a31cb104e34ce3d7798f8914272cf / . / include / openssl / stack_macros.h
blob: 52924c8bfb0f4d5ebb24ac9429bb9ac718d0e56b [file] [log] [blame]
Adam Langley95c29f32014-06-20 12:00:00 -0700[diff] [blame]1/* Copyright (c) 2014, Google Inc.
2 *
3 * Permission to use, copy, modify, and/or distribute this software for any
4 * purpose with or without fee is hereby granted, provided that the above
5 * copyright notice and this permission notice appear in all copies.
6 *
7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
14
15#if !defined(IN_STACK_H)
16#error "Don't include this file directly. Include stack.h."
17#endif
18
19/* ACCESS_DESCRIPTION */
20#define sk_ACCESS_DESCRIPTION_new(comp) \
21 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new(CHECKED_CAST( \
22 stack_cmp_func, \
23 int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b), \
24 comp)))
25
26#define sk_ACCESS_DESCRIPTION_new_null() \
27 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new_null())
28
29#define sk_ACCESS_DESCRIPTION_num(sk) \
30 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))
31
32#define sk_ACCESS_DESCRIPTION_zero(sk) \
33 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk));
34
35#define sk_ACCESS_DESCRIPTION_value(sk, i) \
36 ((ACCESS_DESCRIPTION *)sk_value( \
37 CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), (i)))
38
39#define sk_ACCESS_DESCRIPTION_set(sk, i, p) \
40 ((ACCESS_DESCRIPTION *)sk_set( \
41 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (i), \
42 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))
43
44#define sk_ACCESS_DESCRIPTION_free(sk) \
45 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))
46
47#define sk_ACCESS_DESCRIPTION_pop_free(sk, free_func) \
48 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
49 CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *), \
50 free_func))
51
52#define sk_ACCESS_DESCRIPTION_insert(sk, p, where) \
53 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
54 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p), (where))
55
56#define sk_ACCESS_DESCRIPTION_delete(sk, where) \
57 ((ACCESS_DESCRIPTION *)sk_delete( \
58 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (where)))
59
60#define sk_ACCESS_DESCRIPTION_delete_ptr(sk, p) \
61 ((ACCESS_DESCRIPTION *)sk_delete_ptr( \
62 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
63 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))
64
65#define sk_ACCESS_DESCRIPTION_find(sk, out_index, p) \
66 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
67 (out_index), CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))
68
69#define sk_ACCESS_DESCRIPTION_shift(sk) \
70 ((ACCESS_DESCRIPTION *)sk_shift( \
71 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))
72
73#define sk_ACCESS_DESCRIPTION_push(sk, p) \
74 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
75 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))
76
77#define sk_ACCESS_DESCRIPTION_pop(sk) \
78 ((ACCESS_DESCRIPTION *)sk_pop( \
79 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))
80
81#define sk_ACCESS_DESCRIPTION_dup(sk) \
82 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_dup( \
83 CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk)))
84
85#define sk_ACCESS_DESCRIPTION_sort(sk) \
86 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))
87
88#define sk_ACCESS_DESCRIPTION_is_sorted(sk) \
89 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk))
90
91#define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp) \
92 ((int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b)) \
93 sk_set_cmp_func( \
94 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
95 CHECKED_CAST(stack_cmp_func, int (*)(const ACCESS_DESCRIPTION **a, \
96 const ACCESS_DESCRIPTION **b), \
97 comp)))
98
99/* ASN1_ADB_TABLE */
100#define sk_ASN1_ADB_TABLE_new(comp) \
101 ((STACK_OF(ASN1_ADB_TABLE) *)sk_new(CHECKED_CAST( \
102 stack_cmp_func, \
103 int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b), comp)))
104
105#define sk_ASN1_ADB_TABLE_new_null() ((STACK_OF(ASN1_ADB_TABLE) *)sk_new_null())
106
107#define sk_ASN1_ADB_TABLE_num(sk) \
108 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))
109
110#define sk_ASN1_ADB_TABLE_zero(sk) \
111 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk));
112
113#define sk_ASN1_ADB_TABLE_value(sk, i) \
114 ((ASN1_ADB_TABLE *)sk_value( \
115 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk), (i)))
116
117#define sk_ASN1_ADB_TABLE_set(sk, i, p) \
118 ((ASN1_ADB_TABLE *)sk_set( \
119 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (i), \
120 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))
121
122#define sk_ASN1_ADB_TABLE_free(sk) \
123 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))
124
125#define sk_ASN1_ADB_TABLE_pop_free(sk, free_func) \
126 sk_pop_free( \
127 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
128 CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func))
129
130#define sk_ASN1_ADB_TABLE_insert(sk, p, where) \
131 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
132 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p), (where))
133
134#define sk_ASN1_ADB_TABLE_delete(sk, where) \
135 ((ASN1_ADB_TABLE *)sk_delete( \
136 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (where)))
137
138#define sk_ASN1_ADB_TABLE_delete_ptr(sk, p) \
139 ((ASN1_ADB_TABLE *)sk_delete_ptr( \
140 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
141 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))
142
143#define sk_ASN1_ADB_TABLE_find(sk, out_index, p) \
144 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (out_index), \
145 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))
146
147#define sk_ASN1_ADB_TABLE_shift(sk) \
148 ((ASN1_ADB_TABLE *)sk_shift( \
149 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))
150
151#define sk_ASN1_ADB_TABLE_push(sk, p) \
152 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
153 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))
154
155#define sk_ASN1_ADB_TABLE_pop(sk) \
156 ((ASN1_ADB_TABLE *)sk_pop( \
157 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))
158
159#define sk_ASN1_ADB_TABLE_dup(sk) \
160 ((STACK_OF(ASN1_ADB_TABLE) *)sk_dup( \
161 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk)))
162
163#define sk_ASN1_ADB_TABLE_sort(sk) \
164 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))
165
166#define sk_ASN1_ADB_TABLE_is_sorted(sk) \
167 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))
168
169#define sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp) \
170 ((int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b)) \
171 sk_set_cmp_func( \
172 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
173 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_ADB_TABLE **a, \
174 const ASN1_ADB_TABLE **b), \
175 comp)))
176
177/* ASN1_GENERALSTRING */
178#define sk_ASN1_GENERALSTRING_new(comp) \
179 ((STACK_OF(ASN1_GENERALSTRING) *)sk_new(CHECKED_CAST( \
180 stack_cmp_func, \
181 int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b), \
182 comp)))
183
184#define sk_ASN1_GENERALSTRING_new_null() \
185 ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())
186
187#define sk_ASN1_GENERALSTRING_num(sk) \
188 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))
189
190#define sk_ASN1_GENERALSTRING_zero(sk) \
191 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk));
192
193#define sk_ASN1_GENERALSTRING_value(sk, i) \
194 ((ASN1_GENERALSTRING *)sk_value( \
195 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), (i)))
196
197#define sk_ASN1_GENERALSTRING_set(sk, i, p) \
198 ((ASN1_GENERALSTRING *)sk_set( \
199 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (i), \
200 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))
201
202#define sk_ASN1_GENERALSTRING_free(sk) \
203 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))
204
205#define sk_ASN1_GENERALSTRING_pop_free(sk, free_func) \
206 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
207 CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *), \
208 free_func))
209
210#define sk_ASN1_GENERALSTRING_insert(sk, p, where) \
211 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
212 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p), (where))
213
214#define sk_ASN1_GENERALSTRING_delete(sk, where) \
215 ((ASN1_GENERALSTRING *)sk_delete( \
216 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (where)))
217
218#define sk_ASN1_GENERALSTRING_delete_ptr(sk, p) \
219 ((ASN1_GENERALSTRING *)sk_delete_ptr( \
220 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
221 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))
222
223#define sk_ASN1_GENERALSTRING_find(sk, out_index, p) \
224 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
225 (out_index), CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))
226
227#define sk_ASN1_GENERALSTRING_shift(sk) \
228 ((ASN1_GENERALSTRING *)sk_shift( \
229 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))
230
231#define sk_ASN1_GENERALSTRING_push(sk, p) \
232 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
233 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))
234
235#define sk_ASN1_GENERALSTRING_pop(sk) \
236 ((ASN1_GENERALSTRING *)sk_pop( \
237 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))
238
239#define sk_ASN1_GENERALSTRING_dup(sk) \
240 ((STACK_OF(ASN1_GENERALSTRING) *)sk_dup( \
241 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk)))
242
243#define sk_ASN1_GENERALSTRING_sort(sk) \
244 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))
245
246#define sk_ASN1_GENERALSTRING_is_sorted(sk) \
247 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))
248
249#define sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp) \
250 ((int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b)) \
251 sk_set_cmp_func( \
252 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
253 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_GENERALSTRING **a, \
254 const ASN1_GENERALSTRING **b), \
255 comp)))
256
257/* ASN1_INTEGER */
258#define sk_ASN1_INTEGER_new(comp) \
259 ((STACK_OF(ASN1_INTEGER) *)sk_new(CHECKED_CAST( \
260 stack_cmp_func, int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \
261 comp)))
262
263#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)sk_new_null())
264
265#define sk_ASN1_INTEGER_num(sk) \
266 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))
267
268#define sk_ASN1_INTEGER_zero(sk) \
269 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk));
270
271#define sk_ASN1_INTEGER_value(sk, i) \
272 ((ASN1_INTEGER *)sk_value( \
273 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk), (i)))
274
275#define sk_ASN1_INTEGER_set(sk, i, p) \
276 ((ASN1_INTEGER *)sk_set( \
277 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (i), \
278 CHECKED_CAST(void *, ASN1_INTEGER *, p)))
279
280#define sk_ASN1_INTEGER_free(sk) \
281 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))
282
283#define sk_ASN1_INTEGER_pop_free(sk, free_func) \
284 sk_pop_free( \
285 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
286 CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func))
287
288#define sk_ASN1_INTEGER_insert(sk, p, where) \
289 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
290 CHECKED_CAST(void *, ASN1_INTEGER *, p), (where))
291
292#define sk_ASN1_INTEGER_delete(sk, where) \
293 ((ASN1_INTEGER *)sk_delete( \
294 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (where)))
295
296#define sk_ASN1_INTEGER_delete_ptr(sk, p) \
297 ((ASN1_INTEGER *)sk_delete_ptr( \
298 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
299 CHECKED_CAST(void *, ASN1_INTEGER *, p)))
300
301#define sk_ASN1_INTEGER_find(sk, out_index, p) \
302 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (out_index), \
303 CHECKED_CAST(void *, ASN1_INTEGER *, p))
304
305#define sk_ASN1_INTEGER_shift(sk) \
306 ((ASN1_INTEGER *)sk_shift( \
307 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))
308
309#define sk_ASN1_INTEGER_push(sk, p) \
310 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
311 CHECKED_CAST(void *, ASN1_INTEGER *, p))
312
313#define sk_ASN1_INTEGER_pop(sk) \
314 ((ASN1_INTEGER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))
315
316#define sk_ASN1_INTEGER_dup(sk) \
317 ((STACK_OF(ASN1_INTEGER) *)sk_dup( \
318 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk)))
319
320#define sk_ASN1_INTEGER_sort(sk) \
321 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))
322
323#define sk_ASN1_INTEGER_is_sorted(sk) \
324 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk))
325
326#define sk_ASN1_INTEGER_set_cmp_func(sk, comp) \
327 ((int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b))sk_set_cmp_func( \
328 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
329 CHECKED_CAST(stack_cmp_func, \
330 int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \
331 comp)))
332
333/* ASN1_OBJECT */
334#define sk_ASN1_OBJECT_new(comp) \
335 ((STACK_OF(ASN1_OBJECT) *)sk_new(CHECKED_CAST( \
336 stack_cmp_func, int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \
337 comp)))
338
339#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)sk_new_null())
340
341#define sk_ASN1_OBJECT_num(sk) \
342 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))
343
344#define sk_ASN1_OBJECT_zero(sk) \
345 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk));
346
347#define sk_ASN1_OBJECT_value(sk, i) \
348 ((ASN1_OBJECT *)sk_value( \
349 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk), (i)))
350
351#define sk_ASN1_OBJECT_set(sk, i, p) \
352 ((ASN1_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
353 (i), CHECKED_CAST(void *, ASN1_OBJECT *, p)))
354
355#define sk_ASN1_OBJECT_free(sk) \
356 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))
357
358#define sk_ASN1_OBJECT_pop_free(sk, free_func) \
359 sk_pop_free( \
360 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
361 CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func))
362
363#define sk_ASN1_OBJECT_insert(sk, p, where) \
364 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
365 CHECKED_CAST(void *, ASN1_OBJECT *, p), (where))
366
367#define sk_ASN1_OBJECT_delete(sk, where) \
368 ((ASN1_OBJECT *)sk_delete( \
369 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (where)))
370
371#define sk_ASN1_OBJECT_delete_ptr(sk, p) \
372 ((ASN1_OBJECT *)sk_delete_ptr( \
373 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
374 CHECKED_CAST(void *, ASN1_OBJECT *, p)))
375
376#define sk_ASN1_OBJECT_find(sk, out_index, p) \
377 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (out_index), \
378 CHECKED_CAST(void *, ASN1_OBJECT *, p))
379
380#define sk_ASN1_OBJECT_shift(sk) \
381 ((ASN1_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))
382
383#define sk_ASN1_OBJECT_push(sk, p) \
384 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
385 CHECKED_CAST(void *, ASN1_OBJECT *, p))
386
387#define sk_ASN1_OBJECT_pop(sk) \
388 ((ASN1_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))
389
390#define sk_ASN1_OBJECT_dup(sk) \
391 ((STACK_OF(ASN1_OBJECT) *)sk_dup( \
392 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk)))
393
394#define sk_ASN1_OBJECT_sort(sk) \
395 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))
396
397#define sk_ASN1_OBJECT_is_sorted(sk) \
398 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk))
399
400#define sk_ASN1_OBJECT_set_cmp_func(sk, comp) \
401 ((int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b))sk_set_cmp_func( \
402 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
403 CHECKED_CAST(stack_cmp_func, \
404 int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \
405 comp)))
406
407/* ASN1_STRING_TABLE */
408#define sk_ASN1_STRING_TABLE_new(comp) \
409 ((STACK_OF(ASN1_STRING_TABLE) *)sk_new(CHECKED_CAST( \
410 stack_cmp_func, \
411 int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b), \
412 comp)))
413
414#define sk_ASN1_STRING_TABLE_new_null() \
415 ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())
416
417#define sk_ASN1_STRING_TABLE_num(sk) \
418 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))
419
420#define sk_ASN1_STRING_TABLE_zero(sk) \
421 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk));
422
423#define sk_ASN1_STRING_TABLE_value(sk, i) \
424 ((ASN1_STRING_TABLE *)sk_value( \
425 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), (i)))
426
427#define sk_ASN1_STRING_TABLE_set(sk, i, p) \
428 ((ASN1_STRING_TABLE *)sk_set( \
429 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (i), \
430 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))
431
432#define sk_ASN1_STRING_TABLE_free(sk) \
433 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))
434
435#define sk_ASN1_STRING_TABLE_pop_free(sk, free_func) \
436 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
437 CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *), \
438 free_func))
439
440#define sk_ASN1_STRING_TABLE_insert(sk, p, where) \
441 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
442 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p), (where))
443
444#define sk_ASN1_STRING_TABLE_delete(sk, where) \
445 ((ASN1_STRING_TABLE *)sk_delete( \
446 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (where)))
447
448#define sk_ASN1_STRING_TABLE_delete_ptr(sk, p) \
449 ((ASN1_STRING_TABLE *)sk_delete_ptr( \
450 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
451 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))
452
453#define sk_ASN1_STRING_TABLE_find(sk, out_index, p) \
454 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
455 (out_index), CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))
456
457#define sk_ASN1_STRING_TABLE_shift(sk) \
458 ((ASN1_STRING_TABLE *)sk_shift( \
459 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))
460
461#define sk_ASN1_STRING_TABLE_push(sk, p) \
462 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
463 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))
464
465#define sk_ASN1_STRING_TABLE_pop(sk) \
466 ((ASN1_STRING_TABLE *)sk_pop( \
467 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))
468
469#define sk_ASN1_STRING_TABLE_dup(sk) \
470 ((STACK_OF(ASN1_STRING_TABLE) *)sk_dup( \
471 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk)))
472
473#define sk_ASN1_STRING_TABLE_sort(sk) \
474 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))
475
476#define sk_ASN1_STRING_TABLE_is_sorted(sk) \
477 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))
478
479#define sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp) \
480 ((int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b)) \
481 sk_set_cmp_func( \
482 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
483 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_STRING_TABLE **a, \
484 const ASN1_STRING_TABLE **b), \
485 comp)))
486
487/* ASN1_TYPE */
488#define sk_ASN1_TYPE_new(comp) \
489 ((STACK_OF(ASN1_TYPE) *)sk_new( \
490 CHECKED_CAST(stack_cmp_func, \
491 int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))
492
493#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)sk_new_null())
494
495#define sk_ASN1_TYPE_num(sk) \
496 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))
497
498#define sk_ASN1_TYPE_zero(sk) \
499 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk));
500
501#define sk_ASN1_TYPE_value(sk, i) \
502 ((ASN1_TYPE *)sk_value( \
503 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk), (i)))
504
505#define sk_ASN1_TYPE_set(sk, i, p) \
506 ((ASN1_TYPE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (i), \
507 CHECKED_CAST(void *, ASN1_TYPE *, p)))
508
509#define sk_ASN1_TYPE_free(sk) \
510 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))
511
512#define sk_ASN1_TYPE_pop_free(sk, free_func) \
513 sk_pop_free( \
514 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
515 CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func))
516
517#define sk_ASN1_TYPE_insert(sk, p, where) \
518 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
519 CHECKED_CAST(void *, ASN1_TYPE *, p), (where))
520
521#define sk_ASN1_TYPE_delete(sk, where) \
522 ((ASN1_TYPE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
523 (where)))
524
525#define sk_ASN1_TYPE_delete_ptr(sk, p) \
526 ((ASN1_TYPE *)sk_delete_ptr( \
527 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
528 CHECKED_CAST(void *, ASN1_TYPE *, p)))
529
530#define sk_ASN1_TYPE_find(sk, out_index, p) \
531 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (out_index), \
532 CHECKED_CAST(void *, ASN1_TYPE *, p))
533
534#define sk_ASN1_TYPE_shift(sk) \
535 ((ASN1_TYPE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))
536
537#define sk_ASN1_TYPE_push(sk, p) \
538 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
539 CHECKED_CAST(void *, ASN1_TYPE *, p))
540
541#define sk_ASN1_TYPE_pop(sk) \
542 ((ASN1_TYPE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))
543
544#define sk_ASN1_TYPE_dup(sk) \
545 ((STACK_OF(ASN1_TYPE) *)sk_dup( \
546 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk)))
547
548#define sk_ASN1_TYPE_sort(sk) \
549 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))
550
551#define sk_ASN1_TYPE_is_sorted(sk) \
552 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk))
553
554#define sk_ASN1_TYPE_set_cmp_func(sk, comp) \
555 ((int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b))sk_set_cmp_func( \
556 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
557 CHECKED_CAST(stack_cmp_func, \
558 int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))
559
560/* ASN1_VALUE */
561#define sk_ASN1_VALUE_new(comp) \
562 ((STACK_OF(ASN1_VALUE) *)sk_new(CHECKED_CAST( \
563 stack_cmp_func, int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \
564 comp)))
565
566#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)sk_new_null())
567
568#define sk_ASN1_VALUE_num(sk) \
569 sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))
570
571#define sk_ASN1_VALUE_zero(sk) \
572 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk));
573
574#define sk_ASN1_VALUE_value(sk, i) \
575 ((ASN1_VALUE *)sk_value( \
576 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk), (i)))
577
578#define sk_ASN1_VALUE_set(sk, i, p) \
579 ((ASN1_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
580 (i), CHECKED_CAST(void *, ASN1_VALUE *, p)))
581
582#define sk_ASN1_VALUE_free(sk) \
583 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))
584
585#define sk_ASN1_VALUE_pop_free(sk, free_func) \
586 sk_pop_free( \
587 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
588 CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func))
589
590#define sk_ASN1_VALUE_insert(sk, p, where) \
591 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
592 CHECKED_CAST(void *, ASN1_VALUE *, p), (where))
593
594#define sk_ASN1_VALUE_delete(sk, where) \
595 ((ASN1_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
596 (where)))
597
598#define sk_ASN1_VALUE_delete_ptr(sk, p) \
599 ((ASN1_VALUE *)sk_delete_ptr( \
600 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
601 CHECKED_CAST(void *, ASN1_VALUE *, p)))
602
603#define sk_ASN1_VALUE_find(sk, out_index, p) \
604 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), (out_index), \
605 CHECKED_CAST(void *, ASN1_VALUE *, p))
606
607#define sk_ASN1_VALUE_shift(sk) \
608 ((ASN1_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))
609
610#define sk_ASN1_VALUE_push(sk, p) \
611 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
612 CHECKED_CAST(void *, ASN1_VALUE *, p))
613
614#define sk_ASN1_VALUE_pop(sk) \
615 ((ASN1_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))
616
617#define sk_ASN1_VALUE_dup(sk) \
618 ((STACK_OF(ASN1_VALUE) *)sk_dup( \
619 CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk)))
620
621#define sk_ASN1_VALUE_sort(sk) \
622 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))
623
624#define sk_ASN1_VALUE_is_sorted(sk) \
625 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk))
626
627#define sk_ASN1_VALUE_set_cmp_func(sk, comp) \
628 ((int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b))sk_set_cmp_func( \
629 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
630 CHECKED_CAST(stack_cmp_func, \
631 int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \
632 comp)))
633
634/* BIO */
635#define sk_BIO_new(comp) \
636 ((STACK_OF(BIO) *)sk_new(CHECKED_CAST( \
637 stack_cmp_func, int (*)(const BIO **a, const BIO **b), comp)))
638
639#define sk_BIO_new_null() ((STACK_OF(BIO) *)sk_new_null())
640
641#define sk_BIO_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))
642
643#define sk_BIO_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk));
644
645#define sk_BIO_value(sk, i) \
646 ((BIO *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk), (i)))
647
648#define sk_BIO_set(sk, i, p) \
649 ((BIO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (i), \
650 CHECKED_CAST(void *, BIO *, p)))
651
652#define sk_BIO_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))
653
654#define sk_BIO_pop_free(sk, free_func) \
655 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
656 CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func))
657
658#define sk_BIO_insert(sk, p, where) \
659 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
660 CHECKED_CAST(void *, BIO *, p), (where))
661
662#define sk_BIO_delete(sk, where) \
663 ((BIO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (where)))
664
665#define sk_BIO_delete_ptr(sk, p) \
666 ((BIO *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
667 CHECKED_CAST(void *, BIO *, p)))
668
669#define sk_BIO_find(sk, out_index, p) \
670 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (out_index), \
671 CHECKED_CAST(void *, BIO *, p))
672
673#define sk_BIO_shift(sk) \
674 ((BIO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))
675
676#define sk_BIO_push(sk, p) \
677 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
678 CHECKED_CAST(void *, BIO *, p))
679
680#define sk_BIO_pop(sk) \
681 ((BIO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))
682
683#define sk_BIO_dup(sk) \
684 ((STACK_OF(BIO) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk)))
685
686#define sk_BIO_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))
687
688#define sk_BIO_is_sorted(sk) \
689 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk))
690
691#define sk_BIO_set_cmp_func(sk, comp) \
692 ((int (*)(const BIO **a, const BIO **b))sk_set_cmp_func( \
693 CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
694 CHECKED_CAST(stack_cmp_func, int (*)(const BIO **a, const BIO **b), \
695 comp)))
696
697/* BY_DIR_ENTRY */
698#define sk_BY_DIR_ENTRY_new(comp) \
699 ((STACK_OF(BY_DIR_ENTRY) *)sk_new(CHECKED_CAST( \
700 stack_cmp_func, int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \
701 comp)))
702
703#define sk_BY_DIR_ENTRY_new_null() ((STACK_OF(BY_DIR_ENTRY) *)sk_new_null())
704
705#define sk_BY_DIR_ENTRY_num(sk) \
706 sk_num(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))
707
708#define sk_BY_DIR_ENTRY_zero(sk) \
709 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk));
710
711#define sk_BY_DIR_ENTRY_value(sk, i) \
712 ((BY_DIR_ENTRY *)sk_value( \
713 CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk), (i)))
714
715#define sk_BY_DIR_ENTRY_set(sk, i, p) \
716 ((BY_DIR_ENTRY *)sk_set( \
717 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (i), \
718 CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))
719
720#define sk_BY_DIR_ENTRY_free(sk) \
721 sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))
722
723#define sk_BY_DIR_ENTRY_pop_free(sk, free_func) \
724 sk_pop_free( \
725 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
726 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func))
727
728#define sk_BY_DIR_ENTRY_insert(sk, p, where) \
729 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
730 CHECKED_CAST(void *, BY_DIR_ENTRY *, p), (where))
731
732#define sk_BY_DIR_ENTRY_delete(sk, where) \
733 ((BY_DIR_ENTRY *)sk_delete( \
734 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (where)))
735
736#define sk_BY_DIR_ENTRY_delete_ptr(sk, p) \
737 ((BY_DIR_ENTRY *)sk_delete_ptr( \
738 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
739 CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))
740
741#define sk_BY_DIR_ENTRY_find(sk, out_index, p) \
742 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (out_index), \
743 CHECKED_CAST(void *, BY_DIR_ENTRY *, p))
744
745#define sk_BY_DIR_ENTRY_shift(sk) \
746 ((BY_DIR_ENTRY *)sk_shift( \
747 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))
748
749#define sk_BY_DIR_ENTRY_push(sk, p) \
750 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
751 CHECKED_CAST(void *, BY_DIR_ENTRY *, p))
752
753#define sk_BY_DIR_ENTRY_pop(sk) \
754 ((BY_DIR_ENTRY *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))
755
756#define sk_BY_DIR_ENTRY_dup(sk) \
757 ((STACK_OF(BY_DIR_ENTRY) *)sk_dup( \
758 CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk)))
759
760#define sk_BY_DIR_ENTRY_sort(sk) \
761 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))
762
763#define sk_BY_DIR_ENTRY_is_sorted(sk) \
764 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))
765
766#define sk_BY_DIR_ENTRY_set_cmp_func(sk, comp) \
767 ((int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b))sk_set_cmp_func( \
768 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
769 CHECKED_CAST(stack_cmp_func, \
770 int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \
771 comp)))
772
773/* BY_DIR_HASH */
774#define sk_BY_DIR_HASH_new(comp) \
775 ((STACK_OF(BY_DIR_HASH) *)sk_new(CHECKED_CAST( \
776 stack_cmp_func, int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \
777 comp)))
778
779#define sk_BY_DIR_HASH_new_null() ((STACK_OF(BY_DIR_HASH) *)sk_new_null())
780
781#define sk_BY_DIR_HASH_num(sk) \
782 sk_num(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))
783
784#define sk_BY_DIR_HASH_zero(sk) \
785 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk));
786
787#define sk_BY_DIR_HASH_value(sk, i) \
788 ((BY_DIR_HASH *)sk_value( \
789 CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk), (i)))
790
791#define sk_BY_DIR_HASH_set(sk, i, p) \
792 ((BY_DIR_HASH *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
793 (i), CHECKED_CAST(void *, BY_DIR_HASH *, p)))
794
795#define sk_BY_DIR_HASH_free(sk) \
796 sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))
797
798#define sk_BY_DIR_HASH_pop_free(sk, free_func) \
799 sk_pop_free( \
800 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
801 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func))
802
803#define sk_BY_DIR_HASH_insert(sk, p, where) \
804 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
805 CHECKED_CAST(void *, BY_DIR_HASH *, p), (where))
806
807#define sk_BY_DIR_HASH_delete(sk, where) \
808 ((BY_DIR_HASH *)sk_delete( \
809 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (where)))
810
811#define sk_BY_DIR_HASH_delete_ptr(sk, p) \
812 ((BY_DIR_HASH *)sk_delete_ptr( \
813 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
814 CHECKED_CAST(void *, BY_DIR_HASH *, p)))
815
816#define sk_BY_DIR_HASH_find(sk, out_index, p) \
817 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (out_index), \
818 CHECKED_CAST(void *, BY_DIR_HASH *, p))
819
820#define sk_BY_DIR_HASH_shift(sk) \
821 ((BY_DIR_HASH *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))
822
823#define sk_BY_DIR_HASH_push(sk, p) \
824 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
825 CHECKED_CAST(void *, BY_DIR_HASH *, p))
826
827#define sk_BY_DIR_HASH_pop(sk) \
828 ((BY_DIR_HASH *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))
829
830#define sk_BY_DIR_HASH_dup(sk) \
831 ((STACK_OF(BY_DIR_HASH) *)sk_dup( \
832 CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk)))
833
834#define sk_BY_DIR_HASH_sort(sk) \
835 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))
836
837#define sk_BY_DIR_HASH_is_sorted(sk) \
838 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk))
839
840#define sk_BY_DIR_HASH_set_cmp_func(sk, comp) \
841 ((int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b))sk_set_cmp_func( \
842 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
843 CHECKED_CAST(stack_cmp_func, \
844 int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \
845 comp)))
846
847/* CONF_VALUE */
848#define sk_CONF_VALUE_new(comp) \
849 ((STACK_OF(CONF_VALUE) *)sk_new(CHECKED_CAST( \
850 stack_cmp_func, int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \
851 comp)))
852
853#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)sk_new_null())
854
855#define sk_CONF_VALUE_num(sk) \
856 sk_num(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))
857
858#define sk_CONF_VALUE_zero(sk) \
859 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk));
860
861#define sk_CONF_VALUE_value(sk, i) \
862 ((CONF_VALUE *)sk_value( \
863 CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk), (i)))
864
865#define sk_CONF_VALUE_set(sk, i, p) \
866 ((CONF_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
867 (i), CHECKED_CAST(void *, CONF_VALUE *, p)))
868
869#define sk_CONF_VALUE_free(sk) \
870 sk_free(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))
871
872#define sk_CONF_VALUE_pop_free(sk, free_func) \
873 sk_pop_free( \
874 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
875 CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func))
876
877#define sk_CONF_VALUE_insert(sk, p, where) \
878 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
879 CHECKED_CAST(void *, CONF_VALUE *, p), (where))
880
881#define sk_CONF_VALUE_delete(sk, where) \
882 ((CONF_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
883 (where)))
884
885#define sk_CONF_VALUE_delete_ptr(sk, p) \
886 ((CONF_VALUE *)sk_delete_ptr( \
887 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
888 CHECKED_CAST(void *, CONF_VALUE *, p)))
889
890#define sk_CONF_VALUE_find(sk, out_index, p) \
891 sk_find(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), (out_index), \
892 CHECKED_CAST(void *, CONF_VALUE *, p))
893
894#define sk_CONF_VALUE_shift(sk) \
895 ((CONF_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))
896
897#define sk_CONF_VALUE_push(sk, p) \
898 sk_push(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
899 CHECKED_CAST(void *, CONF_VALUE *, p))
900
901#define sk_CONF_VALUE_pop(sk) \
902 ((CONF_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))
903
904#define sk_CONF_VALUE_dup(sk) \
905 ((STACK_OF(CONF_VALUE) *)sk_dup( \
906 CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk)))
907
908#define sk_CONF_VALUE_sort(sk) \
909 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))
910
911#define sk_CONF_VALUE_is_sorted(sk) \
912 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk))
913
914#define sk_CONF_VALUE_set_cmp_func(sk, comp) \
915 ((int (*)(const CONF_VALUE **a, const CONF_VALUE **b))sk_set_cmp_func( \
916 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
917 CHECKED_CAST(stack_cmp_func, \
918 int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \
919 comp)))
920
921/* CRYPTO_EX_DATA_FUNCS */
922#define sk_CRYPTO_EX_DATA_FUNCS_new(comp) \
923 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new(CHECKED_CAST( \
924 stack_cmp_func, \
925 int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b), \
926 comp)))
927
928#define sk_CRYPTO_EX_DATA_FUNCS_new_null() \
929 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())
930
931#define sk_CRYPTO_EX_DATA_FUNCS_num(sk) \
932 sk_num(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
933
934#define sk_CRYPTO_EX_DATA_FUNCS_zero(sk) \
935 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk));
936
937#define sk_CRYPTO_EX_DATA_FUNCS_value(sk, i) \
938 ((CRYPTO_EX_DATA_FUNCS *)sk_value( \
939 CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
940 (i)))
941
942#define sk_CRYPTO_EX_DATA_FUNCS_set(sk, i, p) \
943 ((CRYPTO_EX_DATA_FUNCS *)sk_set( \
944 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (i), \
945 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))
946
947#define sk_CRYPTO_EX_DATA_FUNCS_free(sk) \
948 sk_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
949
950#define sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func) \
951 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
952 CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *), \
953 free_func))
954
955#define sk_CRYPTO_EX_DATA_FUNCS_insert(sk, p, where) \
956 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
957 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p), (where))
958
959#define sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where) \
960 ((CRYPTO_EX_DATA_FUNCS *)sk_delete( \
961 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (where)))
962
963#define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p) \
964 ((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr( \
965 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
966 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))
967
968#define sk_CRYPTO_EX_DATA_FUNCS_find(sk, out_index, p) \
969 sk_find(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
970 (out_index), CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))
971
972#define sk_CRYPTO_EX_DATA_FUNCS_shift(sk) \
973 ((CRYPTO_EX_DATA_FUNCS *)sk_shift( \
974 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))
975
976#define sk_CRYPTO_EX_DATA_FUNCS_push(sk, p) \
977 sk_push(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
978 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))
979
980#define sk_CRYPTO_EX_DATA_FUNCS_pop(sk) \
981 ((CRYPTO_EX_DATA_FUNCS *)sk_pop( \
982 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))
983
984#define sk_CRYPTO_EX_DATA_FUNCS_dup(sk) \
985 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_dup( \
986 CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))
987
988#define sk_CRYPTO_EX_DATA_FUNCS_sort(sk) \
989 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
990
991#define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk) \
992 sk_is_sorted( \
993 CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
994
995#define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp) \
996 ((int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b)) \
997 sk_set_cmp_func( \
998 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
999 CHECKED_CAST(stack_cmp_func, int (*)(const CRYPTO_EX_DATA_FUNCS **a, \
1000 const CRYPTO_EX_DATA_FUNCS **b), \
1001 comp)))
1002
1003/* DIST_POINT */
1004#define sk_DIST_POINT_new(comp) \
1005 ((STACK_OF(DIST_POINT) *)sk_new(CHECKED_CAST( \
1006 stack_cmp_func, int (*)(const DIST_POINT **a, const DIST_POINT **b), \
1007 comp)))
1008
1009#define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)sk_new_null())
1010
1011#define sk_DIST_POINT_num(sk) \
1012 sk_num(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))
1013
1014#define sk_DIST_POINT_zero(sk) \
1015 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk));
1016
1017#define sk_DIST_POINT_value(sk, i) \
1018 ((DIST_POINT *)sk_value( \
1019 CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk), (i)))
1020
1021#define sk_DIST_POINT_set(sk, i, p) \
1022 ((DIST_POINT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1023 (i), CHECKED_CAST(void *, DIST_POINT *, p)))
1024
1025#define sk_DIST_POINT_free(sk) \
1026 sk_free(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))
1027
1028#define sk_DIST_POINT_pop_free(sk, free_func) \
1029 sk_pop_free( \
1030 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1031 CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func))
1032
1033#define sk_DIST_POINT_insert(sk, p, where) \
1034 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1035 CHECKED_CAST(void *, DIST_POINT *, p), (where))
1036
1037#define sk_DIST_POINT_delete(sk, where) \
1038 ((DIST_POINT *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1039 (where)))
1040
1041#define sk_DIST_POINT_delete_ptr(sk, p) \
1042 ((DIST_POINT *)sk_delete_ptr( \
1043 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1044 CHECKED_CAST(void *, DIST_POINT *, p)))
1045
1046#define sk_DIST_POINT_find(sk, out_index, p) \
1047 sk_find(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), (out_index), \
1048 CHECKED_CAST(void *, DIST_POINT *, p))
1049
1050#define sk_DIST_POINT_shift(sk) \
1051 ((DIST_POINT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))
1052
1053#define sk_DIST_POINT_push(sk, p) \
1054 sk_push(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1055 CHECKED_CAST(void *, DIST_POINT *, p))
1056
1057#define sk_DIST_POINT_pop(sk) \
1058 ((DIST_POINT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))
1059
1060#define sk_DIST_POINT_dup(sk) \
1061 ((STACK_OF(DIST_POINT) *)sk_dup( \
1062 CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk)))
1063
1064#define sk_DIST_POINT_sort(sk) \
1065 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))
1066
1067#define sk_DIST_POINT_is_sorted(sk) \
1068 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk))
1069
1070#define sk_DIST_POINT_set_cmp_func(sk, comp) \
1071 ((int (*)(const DIST_POINT **a, const DIST_POINT **b))sk_set_cmp_func( \
1072 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
1073 CHECKED_CAST(stack_cmp_func, \
1074 int (*)(const DIST_POINT **a, const DIST_POINT **b), \
1075 comp)))
1076
1077/* GENERAL_NAME */
1078#define sk_GENERAL_NAME_new(comp) \
1079 ((STACK_OF(GENERAL_NAME) *)sk_new(CHECKED_CAST( \
1080 stack_cmp_func, int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \
1081 comp)))
1082
1083#define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)sk_new_null())
1084
1085#define sk_GENERAL_NAME_num(sk) \
1086 sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))
1087
1088#define sk_GENERAL_NAME_zero(sk) \
1089 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk));
1090
1091#define sk_GENERAL_NAME_value(sk, i) \
1092 ((GENERAL_NAME *)sk_value( \
1093 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk), (i)))
1094
1095#define sk_GENERAL_NAME_set(sk, i, p) \
1096 ((GENERAL_NAME *)sk_set( \
1097 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (i), \
1098 CHECKED_CAST(void *, GENERAL_NAME *, p)))
1099
1100#define sk_GENERAL_NAME_free(sk) \
1101 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))
1102
1103#define sk_GENERAL_NAME_pop_free(sk, free_func) \
1104 sk_pop_free( \
1105 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
1106 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func))
1107
1108#define sk_GENERAL_NAME_insert(sk, p, where) \
1109 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
1110 CHECKED_CAST(void *, GENERAL_NAME *, p), (where))
1111
1112#define sk_GENERAL_NAME_delete(sk, where) \
1113 ((GENERAL_NAME *)sk_delete( \
1114 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (where)))
1115
1116#define sk_GENERAL_NAME_delete_ptr(sk, p) \
1117 ((GENERAL_NAME *)sk_delete_ptr( \
1118 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
1119 CHECKED_CAST(void *, GENERAL_NAME *, p)))
1120
1121#define sk_GENERAL_NAME_find(sk, out_index, p) \
1122 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (out_index), \
1123 CHECKED_CAST(void *, GENERAL_NAME *, p))
1124
1125#define sk_GENERAL_NAME_shift(sk) \
1126 ((GENERAL_NAME *)sk_shift( \
1127 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))
1128
1129#define sk_GENERAL_NAME_push(sk, p) \
1130 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
1131 CHECKED_CAST(void *, GENERAL_NAME *, p))
1132
1133#define sk_GENERAL_NAME_pop(sk) \
1134 ((GENERAL_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))
1135
1136#define sk_GENERAL_NAME_dup(sk) \
1137 ((STACK_OF(GENERAL_NAME) *)sk_dup( \
1138 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk)))
1139
1140#define sk_GENERAL_NAME_sort(sk) \
1141 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))
1142
1143#define sk_GENERAL_NAME_is_sorted(sk) \
1144 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk))
1145
1146#define sk_GENERAL_NAME_set_cmp_func(sk, comp) \
1147 ((int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b))sk_set_cmp_func( \
1148 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
1149 CHECKED_CAST(stack_cmp_func, \
1150 int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \
1151 comp)))
1152
1153/* GENERAL_NAMES */
1154#define sk_GENERAL_NAMES_new(comp) \
1155 ((STACK_OF(GENERAL_NAMES) *)sk_new(CHECKED_CAST( \
1156 stack_cmp_func, \
1157 int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), comp)))
1158
1159#define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)sk_new_null())
1160
1161#define sk_GENERAL_NAMES_num(sk) \
1162 sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))
1163
1164#define sk_GENERAL_NAMES_zero(sk) \
1165 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk));
1166
1167#define sk_GENERAL_NAMES_value(sk, i) \
1168 ((GENERAL_NAMES *)sk_value( \
1169 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk), (i)))
1170
1171#define sk_GENERAL_NAMES_set(sk, i, p) \
1172 ((GENERAL_NAMES *)sk_set( \
1173 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (i), \
1174 CHECKED_CAST(void *, GENERAL_NAMES *, p)))
1175
1176#define sk_GENERAL_NAMES_free(sk) \
1177 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))
1178
1179#define sk_GENERAL_NAMES_pop_free(sk, free_func) \
1180 sk_pop_free( \
1181 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
1182 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func))
1183
1184#define sk_GENERAL_NAMES_insert(sk, p, where) \
1185 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
1186 CHECKED_CAST(void *, GENERAL_NAMES *, p), (where))
1187
1188#define sk_GENERAL_NAMES_delete(sk, where) \
1189 ((GENERAL_NAMES *)sk_delete( \
1190 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (where)))
1191
1192#define sk_GENERAL_NAMES_delete_ptr(sk, p) \
1193 ((GENERAL_NAMES *)sk_delete_ptr( \
1194 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
1195 CHECKED_CAST(void *, GENERAL_NAMES *, p)))
1196
1197#define sk_GENERAL_NAMES_find(sk, out_index, p) \
1198 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (out_index), \
1199 CHECKED_CAST(void *, GENERAL_NAMES *, p))
1200
1201#define sk_GENERAL_NAMES_shift(sk) \
1202 ((GENERAL_NAMES *)sk_shift( \
1203 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))
1204
1205#define sk_GENERAL_NAMES_push(sk, p) \
1206 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
1207 CHECKED_CAST(void *, GENERAL_NAMES *, p))
1208
1209#define sk_GENERAL_NAMES_pop(sk) \
1210 ((GENERAL_NAMES *)sk_pop( \
1211 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))
1212
1213#define sk_GENERAL_NAMES_dup(sk) \
1214 ((STACK_OF(GENERAL_NAMES) *)sk_dup( \
1215 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk)))
1216
1217#define sk_GENERAL_NAMES_sort(sk) \
1218 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))
1219
1220#define sk_GENERAL_NAMES_is_sorted(sk) \
1221 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk))
1222
1223#define sk_GENERAL_NAMES_set_cmp_func(sk, comp) \
1224 ((int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b))sk_set_cmp_func( \
1225 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
1226 CHECKED_CAST(stack_cmp_func, \
1227 int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), \
1228 comp)))
1229
1230/* GENERAL_SUBTREE */
1231#define sk_GENERAL_SUBTREE_new(comp) \
1232 ((STACK_OF(GENERAL_SUBTREE) *)sk_new(CHECKED_CAST( \
1233 stack_cmp_func, \
1234 int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b), comp)))
1235
1236#define sk_GENERAL_SUBTREE_new_null() \
1237 ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())
1238
1239#define sk_GENERAL_SUBTREE_num(sk) \
1240 sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))
1241
1242#define sk_GENERAL_SUBTREE_zero(sk) \
1243 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk));
1244
1245#define sk_GENERAL_SUBTREE_value(sk, i) \
1246 ((GENERAL_SUBTREE *)sk_value( \
1247 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk), (i)))
1248
1249#define sk_GENERAL_SUBTREE_set(sk, i, p) \
1250 ((GENERAL_SUBTREE *)sk_set( \
1251 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (i), \
1252 CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))
1253
1254#define sk_GENERAL_SUBTREE_free(sk) \
1255 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))
1256
1257#define sk_GENERAL_SUBTREE_pop_free(sk, free_func) \
1258 sk_pop_free( \
1259 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1260 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func))
1261
1262#define sk_GENERAL_SUBTREE_insert(sk, p, where) \
1263 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1264 CHECKED_CAST(void *, GENERAL_SUBTREE *, p), (where))
1265
1266#define sk_GENERAL_SUBTREE_delete(sk, where) \
1267 ((GENERAL_SUBTREE *)sk_delete( \
1268 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (where)))
1269
1270#define sk_GENERAL_SUBTREE_delete_ptr(sk, p) \
1271 ((GENERAL_SUBTREE *)sk_delete_ptr( \
1272 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1273 CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))
1274
1275#define sk_GENERAL_SUBTREE_find(sk, out_index, p) \
1276 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1277 (out_index), CHECKED_CAST(void *, GENERAL_SUBTREE *, p))
1278
1279#define sk_GENERAL_SUBTREE_shift(sk) \
1280 ((GENERAL_SUBTREE *)sk_shift( \
1281 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))
1282
1283#define sk_GENERAL_SUBTREE_push(sk, p) \
1284 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1285 CHECKED_CAST(void *, GENERAL_SUBTREE *, p))
1286
1287#define sk_GENERAL_SUBTREE_pop(sk) \
1288 ((GENERAL_SUBTREE *)sk_pop( \
1289 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))
1290
1291#define sk_GENERAL_SUBTREE_dup(sk) \
1292 ((STACK_OF(GENERAL_SUBTREE) *)sk_dup( \
1293 CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk)))
1294
1295#define sk_GENERAL_SUBTREE_sort(sk) \
1296 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))
1297
1298#define sk_GENERAL_SUBTREE_is_sorted(sk) \
1299 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))
1300
1301#define sk_GENERAL_SUBTREE_set_cmp_func(sk, comp) \
1302 ((int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b)) \
1303 sk_set_cmp_func( \
1304 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
1305 CHECKED_CAST(stack_cmp_func, int (*)(const GENERAL_SUBTREE **a, \
1306 const GENERAL_SUBTREE **b), \
1307 comp)))
1308
1309/* MIME_HEADER */
1310#define sk_MIME_HEADER_new(comp) \
1311 ((STACK_OF(MIME_HEADER) *)sk_new(CHECKED_CAST( \
1312 stack_cmp_func, int (*)(const MIME_HEADER **a, const MIME_HEADER **b), \
1313 comp)))
1314
1315#define sk_MIME_HEADER_new_null() ((STACK_OF(MIME_HEADER) *)sk_new_null())
1316
1317#define sk_MIME_HEADER_num(sk) \
1318 sk_num(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk))
1319
1320#define sk_MIME_HEADER_zero(sk) \
1321 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk));
1322
1323#define sk_MIME_HEADER_value(sk, i) \
1324 ((MIME_HEADER *)sk_value( \
1325 CHECKED_CAST(_STACK *, const STACK_OF(MIME_HEADER) *, sk), (i)))
1326
1327#define sk_MIME_HEADER_set(sk, i, p) \
1328 ((MIME_HEADER *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1329 (i), CHECKED_CAST(void *, MIME_HEADER *, p)))
1330
1331#define sk_MIME_HEADER_free(sk) \
1332 sk_free(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk))
1333
1334#define sk_MIME_HEADER_pop_free(sk, free_func) \
1335 sk_pop_free( \
1336 CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1337 CHECKED_CAST(void (*)(void *), void (*)(MIME_HEADER *), free_func))
1338
1339#define sk_MIME_HEADER_insert(sk, p, where) \
1340 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1341 CHECKED_CAST(void *, MIME_HEADER *, p), (where))
1342
1343#define sk_MIME_HEADER_delete(sk, where) \
1344 ((MIME_HEADER *)sk_delete( \
1345 CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), (where)))
1346
1347#define sk_MIME_HEADER_delete_ptr(sk, p) \
1348 ((MIME_HEADER *)sk_delete_ptr( \
1349 CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1350 CHECKED_CAST(void *, MIME_HEADER *, p)))
1351
1352#define sk_MIME_HEADER_find(sk, out_index, p) \
1353 sk_find(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), (out_index), \
1354 CHECKED_CAST(void *, MIME_HEADER *, p))
1355
1356#define sk_MIME_HEADER_shift(sk) \
1357 ((MIME_HEADER *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk)))
1358
1359#define sk_MIME_HEADER_push(sk, p) \
1360 sk_push(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1361 CHECKED_CAST(void *, MIME_HEADER *, p))
1362
1363#define sk_MIME_HEADER_pop(sk) \
1364 ((MIME_HEADER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk)))
1365
1366#define sk_MIME_HEADER_dup(sk) \
1367 ((STACK_OF(MIME_HEADER) *)sk_dup( \
1368 CHECKED_CAST(_STACK *, const STACK_OF(MIME_HEADER) *, sk)))
1369
1370#define sk_MIME_HEADER_sort(sk) \
1371 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk))
1372
1373#define sk_MIME_HEADER_is_sorted(sk) \
1374 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(MIME_HEADER) *, sk))
1375
1376#define sk_MIME_HEADER_set_cmp_func(sk, comp) \
1377 ((int (*)(const MIME_HEADER **a, const MIME_HEADER **b))sk_set_cmp_func( \
1378 CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), \
1379 CHECKED_CAST(stack_cmp_func, \
1380 int (*)(const MIME_HEADER **a, const MIME_HEADER **b), \
1381 comp)))
1382
1383/* PKCS7_SIGNER_INFO */
1384#define sk_PKCS7_SIGNER_INFO_new(comp) \
1385 ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_new(CHECKED_CAST( \
1386 stack_cmp_func, \
1387 int (*)(const PKCS7_SIGNER_INFO **a, const PKCS7_SIGNER_INFO **b), \
1388 comp)))
1389
1390#define sk_PKCS7_SIGNER_INFO_new_null() \
1391 ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_new_null())
1392
1393#define sk_PKCS7_SIGNER_INFO_num(sk) \
1394 sk_num(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))
1395
1396#define sk_PKCS7_SIGNER_INFO_zero(sk) \
1397 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk));
1398
1399#define sk_PKCS7_SIGNER_INFO_value(sk, i) \
1400 ((PKCS7_SIGNER_INFO *)sk_value( \
1401 CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk), (i)))
1402
1403#define sk_PKCS7_SIGNER_INFO_set(sk, i, p) \
1404 ((PKCS7_SIGNER_INFO *)sk_set( \
1405 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), (i), \
1406 CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p)))
1407
1408#define sk_PKCS7_SIGNER_INFO_free(sk) \
1409 sk_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))
1410
1411#define sk_PKCS7_SIGNER_INFO_pop_free(sk, free_func) \
1412 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1413 CHECKED_CAST(void (*)(void *), void (*)(PKCS7_SIGNER_INFO *), \
1414 free_func))
1415
1416#define sk_PKCS7_SIGNER_INFO_insert(sk, p, where) \
1417 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1418 CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p), (where))
1419
1420#define sk_PKCS7_SIGNER_INFO_delete(sk, where) \
1421 ((PKCS7_SIGNER_INFO *)sk_delete( \
1422 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), (where)))
1423
1424#define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, p) \
1425 ((PKCS7_SIGNER_INFO *)sk_delete_ptr( \
1426 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1427 CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p)))
1428
1429#define sk_PKCS7_SIGNER_INFO_find(sk, out_index, p) \
1430 sk_find(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1431 (out_index), CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p))
1432
1433#define sk_PKCS7_SIGNER_INFO_shift(sk) \
1434 ((PKCS7_SIGNER_INFO *)sk_shift( \
1435 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk)))
1436
1437#define sk_PKCS7_SIGNER_INFO_push(sk, p) \
1438 sk_push(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1439 CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p))
1440
1441#define sk_PKCS7_SIGNER_INFO_pop(sk) \
1442 ((PKCS7_SIGNER_INFO *)sk_pop( \
1443 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk)))
1444
1445#define sk_PKCS7_SIGNER_INFO_dup(sk) \
1446 ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_dup( \
1447 CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk)))
1448
1449#define sk_PKCS7_SIGNER_INFO_sort(sk) \
1450 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))
1451
1452#define sk_PKCS7_SIGNER_INFO_is_sorted(sk) \
1453 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk))
1454
1455#define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, comp) \
1456 ((int (*)(const PKCS7_SIGNER_INFO **a, const PKCS7_SIGNER_INFO **b)) \
1457 sk_set_cmp_func( \
1458 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \
1459 CHECKED_CAST(stack_cmp_func, int (*)(const PKCS7_SIGNER_INFO **a, \
1460 const PKCS7_SIGNER_INFO **b), \
1461 comp)))
1462
1463/* PKCS7_RECIP_INFO */
1464#define sk_PKCS7_RECIP_INFO_new(comp) \
1465 ((STACK_OF(PKCS7_RECIP_INFO) *)sk_new(CHECKED_CAST( \
1466 stack_cmp_func, \
1467 int (*)(const PKCS7_RECIP_INFO **a, const PKCS7_RECIP_INFO **b), comp)))
1468
1469#define sk_PKCS7_RECIP_INFO_new_null() \
1470 ((STACK_OF(PKCS7_RECIP_INFO) *)sk_new_null())
1471
1472#define sk_PKCS7_RECIP_INFO_num(sk) \
1473 sk_num(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))
1474
1475#define sk_PKCS7_RECIP_INFO_zero(sk) \
1476 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk));
1477
1478#define sk_PKCS7_RECIP_INFO_value(sk, i) \
1479 ((PKCS7_RECIP_INFO *)sk_value( \
1480 CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk), (i)))
1481
1482#define sk_PKCS7_RECIP_INFO_set(sk, i, p) \
1483 ((PKCS7_RECIP_INFO *)sk_set( \
1484 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), (i), \
1485 CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p)))
1486
1487#define sk_PKCS7_RECIP_INFO_free(sk) \
1488 sk_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))
1489
1490#define sk_PKCS7_RECIP_INFO_pop_free(sk, free_func) \
1491 sk_pop_free( \
1492 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1493 CHECKED_CAST(void (*)(void *), void (*)(PKCS7_RECIP_INFO *), free_func))
1494
1495#define sk_PKCS7_RECIP_INFO_insert(sk, p, where) \
1496 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1497 CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p), (where))
1498
1499#define sk_PKCS7_RECIP_INFO_delete(sk, where) \
1500 ((PKCS7_RECIP_INFO *)sk_delete( \
1501 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), (where)))
1502
1503#define sk_PKCS7_RECIP_INFO_delete_ptr(sk, p) \
1504 ((PKCS7_RECIP_INFO *)sk_delete_ptr( \
1505 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1506 CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p)))
1507
1508#define sk_PKCS7_RECIP_INFO_find(sk, out_index, p) \
1509 sk_find(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1510 (out_index), CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p))
1511
1512#define sk_PKCS7_RECIP_INFO_shift(sk) \
1513 ((PKCS7_RECIP_INFO *)sk_shift( \
1514 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk)))
1515
1516#define sk_PKCS7_RECIP_INFO_push(sk, p) \
1517 sk_push(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1518 CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p))
1519
1520#define sk_PKCS7_RECIP_INFO_pop(sk) \
1521 ((PKCS7_RECIP_INFO *)sk_pop( \
1522 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk)))
1523
1524#define sk_PKCS7_RECIP_INFO_dup(sk) \
1525 ((STACK_OF(PKCS7_RECIP_INFO) *)sk_dup( \
1526 CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk)))
1527
1528#define sk_PKCS7_RECIP_INFO_sort(sk) \
1529 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))
1530
1531#define sk_PKCS7_RECIP_INFO_is_sorted(sk) \
1532 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk))
1533
1534#define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, comp) \
1535 ((int (*)(const PKCS7_RECIP_INFO **a, const PKCS7_RECIP_INFO **b)) \
1536 sk_set_cmp_func( \
1537 CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \
1538 CHECKED_CAST(stack_cmp_func, int (*)(const PKCS7_RECIP_INFO **a, \
1539 const PKCS7_RECIP_INFO **b), \
1540 comp)))
1541
1542/* POLICYINFO */
1543#define sk_POLICYINFO_new(comp) \
1544 ((STACK_OF(POLICYINFO) *)sk_new(CHECKED_CAST( \
1545 stack_cmp_func, int (*)(const POLICYINFO **a, const POLICYINFO **b), \
1546 comp)))
1547
1548#define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)sk_new_null())
1549
1550#define sk_POLICYINFO_num(sk) \
1551 sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))
1552
1553#define sk_POLICYINFO_zero(sk) \
1554 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk));
1555
1556#define sk_POLICYINFO_value(sk, i) \
1557 ((POLICYINFO *)sk_value( \
1558 CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk), (i)))
1559
1560#define sk_POLICYINFO_set(sk, i, p) \
1561 ((POLICYINFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1562 (i), CHECKED_CAST(void *, POLICYINFO *, p)))
1563
1564#define sk_POLICYINFO_free(sk) \
1565 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))
1566
1567#define sk_POLICYINFO_pop_free(sk, free_func) \
1568 sk_pop_free( \
1569 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1570 CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func))
1571
1572#define sk_POLICYINFO_insert(sk, p, where) \
1573 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1574 CHECKED_CAST(void *, POLICYINFO *, p), (where))
1575
1576#define sk_POLICYINFO_delete(sk, where) \
1577 ((POLICYINFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1578 (where)))
1579
1580#define sk_POLICYINFO_delete_ptr(sk, p) \
1581 ((POLICYINFO *)sk_delete_ptr( \
1582 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1583 CHECKED_CAST(void *, POLICYINFO *, p)))
1584
1585#define sk_POLICYINFO_find(sk, out_index, p) \
1586 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), (out_index), \
1587 CHECKED_CAST(void *, POLICYINFO *, p))
1588
1589#define sk_POLICYINFO_shift(sk) \
1590 ((POLICYINFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))
1591
1592#define sk_POLICYINFO_push(sk, p) \
1593 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1594 CHECKED_CAST(void *, POLICYINFO *, p))
1595
1596#define sk_POLICYINFO_pop(sk) \
1597 ((POLICYINFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))
1598
1599#define sk_POLICYINFO_dup(sk) \
1600 ((STACK_OF(POLICYINFO) *)sk_dup( \
1601 CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk)))
1602
1603#define sk_POLICYINFO_sort(sk) \
1604 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))
1605
1606#define sk_POLICYINFO_is_sorted(sk) \
1607 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk))
1608
1609#define sk_POLICYINFO_set_cmp_func(sk, comp) \
1610 ((int (*)(const POLICYINFO **a, const POLICYINFO **b))sk_set_cmp_func( \
1611 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
1612 CHECKED_CAST(stack_cmp_func, \
1613 int (*)(const POLICYINFO **a, const POLICYINFO **b), \
1614 comp)))
1615
1616/* POLICYQUALINFO */
1617#define sk_POLICYQUALINFO_new(comp) \
1618 ((STACK_OF(POLICYQUALINFO) *)sk_new(CHECKED_CAST( \
1619 stack_cmp_func, \
1620 int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b), comp)))
1621
1622#define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)sk_new_null())
1623
1624#define sk_POLICYQUALINFO_num(sk) \
1625 sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))
1626
1627#define sk_POLICYQUALINFO_zero(sk) \
1628 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk));
1629
1630#define sk_POLICYQUALINFO_value(sk, i) \
1631 ((POLICYQUALINFO *)sk_value( \
1632 CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk), (i)))
1633
1634#define sk_POLICYQUALINFO_set(sk, i, p) \
1635 ((POLICYQUALINFO *)sk_set( \
1636 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (i), \
1637 CHECKED_CAST(void *, POLICYQUALINFO *, p)))
1638
1639#define sk_POLICYQUALINFO_free(sk) \
1640 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))
1641
1642#define sk_POLICYQUALINFO_pop_free(sk, free_func) \
1643 sk_pop_free( \
1644 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
1645 CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func))
1646
1647#define sk_POLICYQUALINFO_insert(sk, p, where) \
1648 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
1649 CHECKED_CAST(void *, POLICYQUALINFO *, p), (where))
1650
1651#define sk_POLICYQUALINFO_delete(sk, where) \
1652 ((POLICYQUALINFO *)sk_delete( \
1653 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (where)))
1654
1655#define sk_POLICYQUALINFO_delete_ptr(sk, p) \
1656 ((POLICYQUALINFO *)sk_delete_ptr( \
1657 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
1658 CHECKED_CAST(void *, POLICYQUALINFO *, p)))
1659
1660#define sk_POLICYQUALINFO_find(sk, out_index, p) \
1661 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (out_index), \
1662 CHECKED_CAST(void *, POLICYQUALINFO *, p))
1663
1664#define sk_POLICYQUALINFO_shift(sk) \
1665 ((POLICYQUALINFO *)sk_shift( \
1666 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))
1667
1668#define sk_POLICYQUALINFO_push(sk, p) \
1669 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
1670 CHECKED_CAST(void *, POLICYQUALINFO *, p))
1671
1672#define sk_POLICYQUALINFO_pop(sk) \
1673 ((POLICYQUALINFO *)sk_pop( \
1674 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))
1675
1676#define sk_POLICYQUALINFO_dup(sk) \
1677 ((STACK_OF(POLICYQUALINFO) *)sk_dup( \
1678 CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk)))
1679
1680#define sk_POLICYQUALINFO_sort(sk) \
1681 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))
1682
1683#define sk_POLICYQUALINFO_is_sorted(sk) \
1684 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk))
1685
1686#define sk_POLICYQUALINFO_set_cmp_func(sk, comp) \
1687 ((int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b)) \
1688 sk_set_cmp_func( \
1689 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
1690 CHECKED_CAST(stack_cmp_func, int (*)(const POLICYQUALINFO **a, \
1691 const POLICYQUALINFO **b), \
1692 comp)))
1693
1694/* POLICY_MAPPING */
1695#define sk_POLICY_MAPPING_new(comp) \
1696 ((STACK_OF(POLICY_MAPPING) *)sk_new(CHECKED_CAST( \
1697 stack_cmp_func, \
1698 int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b), comp)))
1699
1700#define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)sk_new_null())
1701
1702#define sk_POLICY_MAPPING_num(sk) \
1703 sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))
1704
1705#define sk_POLICY_MAPPING_zero(sk) \
1706 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk));
1707
1708#define sk_POLICY_MAPPING_value(sk, i) \
1709 ((POLICY_MAPPING *)sk_value( \
1710 CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk), (i)))
1711
1712#define sk_POLICY_MAPPING_set(sk, i, p) \
1713 ((POLICY_MAPPING *)sk_set( \
1714 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (i), \
1715 CHECKED_CAST(void *, POLICY_MAPPING *, p)))
1716
1717#define sk_POLICY_MAPPING_free(sk) \
1718 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))
1719
1720#define sk_POLICY_MAPPING_pop_free(sk, free_func) \
1721 sk_pop_free( \
1722 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
1723 CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func))
1724
1725#define sk_POLICY_MAPPING_insert(sk, p, where) \
1726 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
1727 CHECKED_CAST(void *, POLICY_MAPPING *, p), (where))
1728
1729#define sk_POLICY_MAPPING_delete(sk, where) \
1730 ((POLICY_MAPPING *)sk_delete( \
1731 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (where)))
1732
1733#define sk_POLICY_MAPPING_delete_ptr(sk, p) \
1734 ((POLICY_MAPPING *)sk_delete_ptr( \
1735 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
1736 CHECKED_CAST(void *, POLICY_MAPPING *, p)))
1737
1738#define sk_POLICY_MAPPING_find(sk, out_index, p) \
1739 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (out_index), \
1740 CHECKED_CAST(void *, POLICY_MAPPING *, p))
1741
1742#define sk_POLICY_MAPPING_shift(sk) \
1743 ((POLICY_MAPPING *)sk_shift( \
1744 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))
1745
1746#define sk_POLICY_MAPPING_push(sk, p) \
1747 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
1748 CHECKED_CAST(void *, POLICY_MAPPING *, p))
1749
1750#define sk_POLICY_MAPPING_pop(sk) \
1751 ((POLICY_MAPPING *)sk_pop( \
1752 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))
1753
1754#define sk_POLICY_MAPPING_dup(sk) \
1755 ((STACK_OF(POLICY_MAPPING) *)sk_dup( \
1756 CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk)))
1757
1758#define sk_POLICY_MAPPING_sort(sk) \
1759 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))
1760
1761#define sk_POLICY_MAPPING_is_sorted(sk) \
1762 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk))
1763
1764#define sk_POLICY_MAPPING_set_cmp_func(sk, comp) \
1765 ((int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b)) \
1766 sk_set_cmp_func( \
1767 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
1768 CHECKED_CAST(stack_cmp_func, int (*)(const POLICY_MAPPING **a, \
1769 const POLICY_MAPPING **b), \
1770 comp)))
1771
1772/* SRTP_PROTECTION_PROFILE */
1773#define sk_SRTP_PROTECTION_PROFILE_new(comp) \
1774 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new( \
1775 CHECKED_CAST(stack_cmp_func, int (*)(const SRTP_PROTECTION_PROFILE **a, \
1776 const SRTP_PROTECTION_PROFILE **b), \
1777 comp)))
1778
1779#define sk_SRTP_PROTECTION_PROFILE_new_null() \
1780 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())
1781
1782#define sk_SRTP_PROTECTION_PROFILE_num(sk) \
1783 sk_num(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
1784
1785#define sk_SRTP_PROTECTION_PROFILE_zero(sk) \
1786 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));
1787
1788#define sk_SRTP_PROTECTION_PROFILE_value(sk, i) \
1789 ((SRTP_PROTECTION_PROFILE *)sk_value( \
1790 CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1791 (i)))
1792
1793#define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p) \
1794 ((SRTP_PROTECTION_PROFILE *)sk_set( \
1795 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \
1796 CHECKED_CAST(void *, SRTP_PROTECTION_PROFILE *, p)))
1797
1798#define sk_SRTP_PROTECTION_PROFILE_free(sk) \
1799 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
1800
1801#define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func) \
1802 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1803 CHECKED_CAST(void (*)(void *), \
1804 void (*)(SRTP_PROTECTION_PROFILE *), free_func))
1805
1806#define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where) \
1807 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1808 CHECKED_CAST(void *, SRTP_PROTECTION_PROFILE *, p), (where))
1809
1810#define sk_SRTP_PROTECTION_PROFILE_delete(sk, where) \
1811 ((SRTP_PROTECTION_PROFILE *)sk_delete( \
1812 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1813 (where)))
1814
1815#define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p) \
1816 ((SRTP_PROTECTION_PROFILE *)sk_delete_ptr( \
1817 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1818 CHECKED_CAST(void *, SRTP_PROTECTION_PROFILE *, p)))
1819
1820#define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p) \
1821 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1822 (out_index), CHECKED_CAST(void *, SRTP_PROTECTION_PROFILE *, p))
1823
1824#define sk_SRTP_PROTECTION_PROFILE_shift(sk) \
1825 ((SRTP_PROTECTION_PROFILE *)sk_shift( \
1826 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))
1827
1828#define sk_SRTP_PROTECTION_PROFILE_push(sk, p) \
1829 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1830 CHECKED_CAST(void *, SRTP_PROTECTION_PROFILE *, p))
1831
1832#define sk_SRTP_PROTECTION_PROFILE_pop(sk) \
1833 ((SRTP_PROTECTION_PROFILE *)sk_pop( \
1834 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))
1835
1836#define sk_SRTP_PROTECTION_PROFILE_dup(sk) \
1837 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup( \
1838 CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))
1839
1840#define sk_SRTP_PROTECTION_PROFILE_sort(sk) \
1841 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
1842
1843#define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \
1844 sk_is_sorted( \
1845 CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
1846
1847#define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp) \
1848 ((int (*)(const SRTP_PROTECTION_PROFILE **a, \
1849 const SRTP_PROTECTION_PROFILE **b)) \
1850 sk_set_cmp_func( \
1851 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
1852 CHECKED_CAST(stack_cmp_func, \
1853 int (*)(const SRTP_PROTECTION_PROFILE **a, \
1854 const SRTP_PROTECTION_PROFILE **b), \
1855 comp)))
1856
1857/* SSL_CIPHER */
1858#define sk_SSL_CIPHER_new(comp) \
1859 ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \
1860 stack_cmp_func, int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b), \
1861 comp)))
1862
1863#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null())
1864
1865#define sk_SSL_CIPHER_num(sk) \
1866 sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))
1867
1868#define sk_SSL_CIPHER_zero(sk) \
1869 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));
1870
1871#define sk_SSL_CIPHER_value(sk, i) \
1872 ((SSL_CIPHER *)sk_value( \
1873 CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))
1874
1875#define sk_SSL_CIPHER_set(sk, i, p) \
1876 ((SSL_CIPHER *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1877 (i), CHECKED_CAST(void *, SSL_CIPHER *, p)))
1878
1879#define sk_SSL_CIPHER_free(sk) \
1880 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))
1881
1882#define sk_SSL_CIPHER_pop_free(sk, free_func) \
1883 sk_pop_free( \
1884 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1885 CHECKED_CAST(void (*)(void *), void (*)(SSL_CIPHER *), free_func))
1886
1887#define sk_SSL_CIPHER_insert(sk, p, where) \
1888 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1889 CHECKED_CAST(void *, SSL_CIPHER *, p), (where))
1890
1891#define sk_SSL_CIPHER_delete(sk, where) \
1892 ((SSL_CIPHER *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1893 (where)))
1894
1895#define sk_SSL_CIPHER_delete_ptr(sk, p) \
1896 ((SSL_CIPHER *)sk_delete_ptr( \
1897 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1898 CHECKED_CAST(void *, SSL_CIPHER *, p)))
1899
1900#define sk_SSL_CIPHER_find(sk, out_index, p) \
1901 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \
1902 CHECKED_CAST(void *, SSL_CIPHER *, p))
1903
1904#define sk_SSL_CIPHER_shift(sk) \
1905 ((SSL_CIPHER *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))
1906
1907#define sk_SSL_CIPHER_push(sk, p) \
1908 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1909 CHECKED_CAST(void *, SSL_CIPHER *, p))
1910
1911#define sk_SSL_CIPHER_pop(sk) \
1912 ((SSL_CIPHER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))
1913
1914#define sk_SSL_CIPHER_dup(sk) \
1915 ((STACK_OF(SSL_CIPHER) *)sk_dup( \
1916 CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk)))
1917
1918#define sk_SSL_CIPHER_sort(sk) \
1919 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))
1920
1921#define sk_SSL_CIPHER_is_sorted(sk) \
1922 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk))
1923
1924#define sk_SSL_CIPHER_set_cmp_func(sk, comp) \
1925 ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \
1926 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
1927 CHECKED_CAST(stack_cmp_func, \
1928 int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b), \
1929 comp)))
1930
1931/* SSL_COMP */
1932#define sk_SSL_COMP_new(comp) \
1933 ((STACK_OF(SSL_COMP) *)sk_new(CHECKED_CAST( \
1934 stack_cmp_func, int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))
1935
1936#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)sk_new_null())
1937
1938#define sk_SSL_COMP_num(sk) \
1939 sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))
1940
1941#define sk_SSL_COMP_zero(sk) \
1942 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk));
1943
1944#define sk_SSL_COMP_value(sk, i) \
1945 ((SSL_COMP *)sk_value( \
1946 CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk), (i)))
1947
1948#define sk_SSL_COMP_set(sk, i, p) \
1949 ((SSL_COMP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (i), \
1950 CHECKED_CAST(void *, SSL_COMP *, p)))
1951
1952#define sk_SSL_COMP_free(sk) \
1953 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))
1954
1955#define sk_SSL_COMP_pop_free(sk, free_func) \
1956 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1957 CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func))
1958
1959#define sk_SSL_COMP_insert(sk, p, where) \
1960 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1961 CHECKED_CAST(void *, SSL_COMP *, p), (where))
1962
1963#define sk_SSL_COMP_delete(sk, where) \
1964 ((SSL_COMP *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1965 (where)))
1966
1967#define sk_SSL_COMP_delete_ptr(sk, p) \
1968 ((SSL_COMP *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1969 CHECKED_CAST(void *, SSL_COMP *, p)))
1970
1971#define sk_SSL_COMP_find(sk, out_index, p) \
1972 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (out_index), \
1973 CHECKED_CAST(void *, SSL_COMP *, p))
1974
1975#define sk_SSL_COMP_shift(sk) \
1976 ((SSL_COMP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))
1977
1978#define sk_SSL_COMP_push(sk, p) \
1979 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1980 CHECKED_CAST(void *, SSL_COMP *, p))
1981
1982#define sk_SSL_COMP_pop(sk) \
1983 ((SSL_COMP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))
1984
1985#define sk_SSL_COMP_dup(sk) \
1986 ((STACK_OF(SSL_COMP) *)sk_dup( \
1987 CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk)))
1988
1989#define sk_SSL_COMP_sort(sk) \
1990 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))
1991
1992#define sk_SSL_COMP_is_sorted(sk) \
1993 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk))
1994
1995#define sk_SSL_COMP_set_cmp_func(sk, comp) \
1996 ((int (*)(const SSL_COMP **a, const SSL_COMP **b))sk_set_cmp_func( \
1997 CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
1998 CHECKED_CAST(stack_cmp_func, \
1999 int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))
2000
2001/* STACK_OF_X509_NAME_ENTRY */
2002#define sk_STACK_OF_X509_NAME_ENTRY_new(comp) \
2003 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \
2004 stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a, \
2005 const STACK_OF_X509_NAME_ENTRY **b), \
2006 comp)))
2007
2008#define sk_STACK_OF_X509_NAME_ENTRY_new_null() \
2009 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())
2010
2011#define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \
2012 sk_num(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
2013
2014#define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \
2015 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk));
2016
2017#define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i) \
2018 ((STACK_OF_X509_NAME_ENTRY *)sk_value( \
2019 CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2020 (i)))
2021
2022#define sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p) \
2023 ((STACK_OF_X509_NAME_ENTRY *)sk_set( \
2024 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \
2025 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))
2026
2027#define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \
2028 sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
2029
2030#define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func) \
2031 sk_pop_free( \
2032 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2033 CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \
2034 free_func))
2035
2036#define sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where) \
2037 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2038 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where))
2039
2040#define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where) \
2041 ((STACK_OF_X509_NAME_ENTRY *)sk_delete( \
2042 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2043 (where)))
2044
2045#define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p) \
2046 ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr( \
2047 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2048 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))
2049
2050#define sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p) \
2051 sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2052 (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))
2053
2054#define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \
2055 ((STACK_OF_X509_NAME_ENTRY *)sk_shift( \
2056 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))
2057
2058#define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p) \
2059 sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2060 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))
2061
2062#define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \
2063 ((STACK_OF_X509_NAME_ENTRY *)sk_pop( \
2064 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))
2065
2066#define sk_STACK_OF_X509_NAME_ENTRY_dup(sk) \
2067 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup( \
2068 CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))
2069
2070#define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \
2071 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
2072
2073#define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \
2074 sk_is_sorted( \
2075 CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
2076
2077#define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp) \
2078 ((int (*)(const STACK_OF_X509_NAME_ENTRY **a, \
2079 const STACK_OF_X509_NAME_ENTRY **b)) \
2080 sk_set_cmp_func( \
2081 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
2082 CHECKED_CAST(stack_cmp_func, \
2083 int (*)(const STACK_OF_X509_NAME_ENTRY **a, \
2084 const STACK_OF_X509_NAME_ENTRY **b), \
2085 comp)))
2086
2087/* SXNETID */
2088#define sk_SXNETID_new(comp) \
2089 ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \
2090 stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))
2091
2092#define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null())
2093
2094#define sk_SXNETID_num(sk) \
2095 sk_num(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))
2096
2097#define sk_SXNETID_zero(sk) \
2098 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));
2099
2100#define sk_SXNETID_value(sk, i) \
2101 ((SXNETID *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk), \
2102 (i)))
2103
2104#define sk_SXNETID_set(sk, i, p) \
2105 ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \
2106 CHECKED_CAST(void *, SXNETID *, p)))
2107
2108#define sk_SXNETID_free(sk) \
2109 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))
2110
2111#define sk_SXNETID_pop_free(sk, free_func) \
2112 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2113 CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))
2114
2115#define sk_SXNETID_insert(sk, p, where) \
2116 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2117 CHECKED_CAST(void *, SXNETID *, p), (where))
2118
2119#define sk_SXNETID_delete(sk, where) \
2120 ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2121 (where)))
2122
2123#define sk_SXNETID_delete_ptr(sk, p) \
2124 ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2125 CHECKED_CAST(void *, SXNETID *, p)))
2126
2127#define sk_SXNETID_find(sk, out_index, p) \
2128 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \
2129 CHECKED_CAST(void *, SXNETID *, p))
2130
2131#define sk_SXNETID_shift(sk) \
2132 ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))
2133
2134#define sk_SXNETID_push(sk, p) \
2135 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2136 CHECKED_CAST(void *, SXNETID *, p))
2137
2138#define sk_SXNETID_pop(sk) \
2139 ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))
2140
2141#define sk_SXNETID_dup(sk) \
2142 ((STACK_OF(SXNETID) *)sk_dup( \
2143 CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk)))
2144
2145#define sk_SXNETID_sort(sk) \
2146 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))
2147
2148#define sk_SXNETID_is_sorted(sk) \
2149 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk))
2150
2151#define sk_SXNETID_set_cmp_func(sk, comp) \
2152 ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \
2153 CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
2154 CHECKED_CAST(stack_cmp_func, \
2155 int (*)(const SXNETID **a, const SXNETID **b), comp)))
2156
2157/* X509 */
2158#define sk_X509_new(comp) \
2159 ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \
2160 stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))
2161
2162#define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null())
2163
2164#define sk_X509_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))
2165
2166#define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));
2167
2168#define sk_X509_value(sk, i) \
2169 ((X509 *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk), (i)))
2170
2171#define sk_X509_set(sk, i, p) \
2172 ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \
2173 CHECKED_CAST(void *, X509 *, p)))
2174
2175#define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))
2176
2177#define sk_X509_pop_free(sk, free_func) \
2178 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
2179 CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))
2180
2181#define sk_X509_insert(sk, p, where) \
2182 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
2183 CHECKED_CAST(void *, X509 *, p), (where))
2184
2185#define sk_X509_delete(sk, where) \
2186 ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))
2187
2188#define sk_X509_delete_ptr(sk, p) \
2189 ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
2190 CHECKED_CAST(void *, X509 *, p)))
2191
2192#define sk_X509_find(sk, out_index, p) \
2193 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \
2194 CHECKED_CAST(void *, X509 *, p))
2195
2196#define sk_X509_shift(sk) \
2197 ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))
2198
2199#define sk_X509_push(sk, p) \
2200 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
2201 CHECKED_CAST(void *, X509 *, p))
2202
2203#define sk_X509_pop(sk) \
2204 ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))
2205
2206#define sk_X509_dup(sk) \
2207 ((STACK_OF(X509) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk)))
2208
2209#define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))
2210
2211#define sk_X509_is_sorted(sk) \
2212 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk))
2213
2214#define sk_X509_set_cmp_func(sk, comp) \
2215 ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func( \
2216 CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
2217 CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \
2218 comp)))
2219
2220/* X509V3_EXT_METHOD */
2221#define sk_X509V3_EXT_METHOD_new(comp) \
2222 ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST( \
2223 stack_cmp_func, \
2224 int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \
2225 comp)))
2226
2227#define sk_X509V3_EXT_METHOD_new_null() \
2228 ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())
2229
2230#define sk_X509V3_EXT_METHOD_num(sk) \
2231 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))
2232
2233#define sk_X509V3_EXT_METHOD_zero(sk) \
2234 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));
2235
2236#define sk_X509V3_EXT_METHOD_value(sk, i) \
2237 ((X509V3_EXT_METHOD *)sk_value( \
2238 CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), (i)))
2239
2240#define sk_X509V3_EXT_METHOD_set(sk, i, p) \
2241 ((X509V3_EXT_METHOD *)sk_set( \
2242 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \
2243 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))
2244
2245#define sk_X509V3_EXT_METHOD_free(sk) \
2246 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))
2247
2248#define sk_X509V3_EXT_METHOD_pop_free(sk, free_func) \
2249 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2250 CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \
2251 free_func))
2252
2253#define sk_X509V3_EXT_METHOD_insert(sk, p, where) \
2254 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2255 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))
2256
2257#define sk_X509V3_EXT_METHOD_delete(sk, where) \
2258 ((X509V3_EXT_METHOD *)sk_delete( \
2259 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))
2260
2261#define sk_X509V3_EXT_METHOD_delete_ptr(sk, p) \
2262 ((X509V3_EXT_METHOD *)sk_delete_ptr( \
2263 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2264 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))
2265
2266#define sk_X509V3_EXT_METHOD_find(sk, out_index, p) \
2267 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2268 (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))
2269
2270#define sk_X509V3_EXT_METHOD_shift(sk) \
2271 ((X509V3_EXT_METHOD *)sk_shift( \
2272 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))
2273
2274#define sk_X509V3_EXT_METHOD_push(sk, p) \
2275 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2276 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))
2277
2278#define sk_X509V3_EXT_METHOD_pop(sk) \
2279 ((X509V3_EXT_METHOD *)sk_pop( \
2280 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))
2281
2282#define sk_X509V3_EXT_METHOD_dup(sk) \
2283 ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \
2284 CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))
2285
2286#define sk_X509V3_EXT_METHOD_sort(sk) \
2287 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))
2288
2289#define sk_X509V3_EXT_METHOD_is_sorted(sk) \
2290 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))
2291
2292#define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp) \
2293 ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b)) \
2294 sk_set_cmp_func( \
2295 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
2296 CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a, \
2297 const X509V3_EXT_METHOD **b), \
2298 comp)))
2299
2300/* X509_ALGOR */
2301#define sk_X509_ALGOR_new(comp) \
2302 ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST( \
2303 stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \
2304 comp)))
2305
2306#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null())
2307
2308#define sk_X509_ALGOR_num(sk) \
2309 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))
2310
2311#define sk_X509_ALGOR_zero(sk) \
2312 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));
2313
2314#define sk_X509_ALGOR_value(sk, i) \
2315 ((X509_ALGOR *)sk_value( \
2316 CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))
2317
2318#define sk_X509_ALGOR_set(sk, i, p) \
2319 ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2320 (i), CHECKED_CAST(void *, X509_ALGOR *, p)))
2321
2322#define sk_X509_ALGOR_free(sk) \
2323 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))
2324
2325#define sk_X509_ALGOR_pop_free(sk, free_func) \
2326 sk_pop_free( \
2327 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2328 CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))
2329
2330#define sk_X509_ALGOR_insert(sk, p, where) \
2331 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2332 CHECKED_CAST(void *, X509_ALGOR *, p), (where))
2333
2334#define sk_X509_ALGOR_delete(sk, where) \
2335 ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2336 (where)))
2337
2338#define sk_X509_ALGOR_delete_ptr(sk, p) \
2339 ((X509_ALGOR *)sk_delete_ptr( \
2340 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2341 CHECKED_CAST(void *, X509_ALGOR *, p)))
2342
2343#define sk_X509_ALGOR_find(sk, out_index, p) \
2344 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \
2345 CHECKED_CAST(void *, X509_ALGOR *, p))
2346
2347#define sk_X509_ALGOR_shift(sk) \
2348 ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))
2349
2350#define sk_X509_ALGOR_push(sk, p) \
2351 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2352 CHECKED_CAST(void *, X509_ALGOR *, p))
2353
2354#define sk_X509_ALGOR_pop(sk) \
2355 ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))
2356
2357#define sk_X509_ALGOR_dup(sk) \
2358 ((STACK_OF(X509_ALGOR) *)sk_dup( \
2359 CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk)))
2360
2361#define sk_X509_ALGOR_sort(sk) \
2362 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))
2363
2364#define sk_X509_ALGOR_is_sorted(sk) \
2365 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk))
2366
2367#define sk_X509_ALGOR_set_cmp_func(sk, comp) \
2368 ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \
2369 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
2370 CHECKED_CAST(stack_cmp_func, \
2371 int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \
2372 comp)))
2373
2374/* X509_ATTRIBUTE */
2375#define sk_X509_ATTRIBUTE_new(comp) \
2376 ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \
2377 stack_cmp_func, \
2378 int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))
2379
2380#define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())
2381
2382#define sk_X509_ATTRIBUTE_num(sk) \
2383 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))
2384
2385#define sk_X509_ATTRIBUTE_zero(sk) \
2386 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));
2387
2388#define sk_X509_ATTRIBUTE_value(sk, i) \
2389 ((X509_ATTRIBUTE *)sk_value( \
2390 CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), (i)))
2391
2392#define sk_X509_ATTRIBUTE_set(sk, i, p) \
2393 ((X509_ATTRIBUTE *)sk_set( \
2394 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \
2395 CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))
2396
2397#define sk_X509_ATTRIBUTE_free(sk) \
2398 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))
2399
2400#define sk_X509_ATTRIBUTE_pop_free(sk, free_func) \
2401 sk_pop_free( \
2402 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
2403 CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))
2404
2405#define sk_X509_ATTRIBUTE_insert(sk, p, where) \
2406 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
2407 CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))
2408
2409#define sk_X509_ATTRIBUTE_delete(sk, where) \
2410 ((X509_ATTRIBUTE *)sk_delete( \
2411 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))
2412
2413#define sk_X509_ATTRIBUTE_delete_ptr(sk, p) \
2414 ((X509_ATTRIBUTE *)sk_delete_ptr( \
2415 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
2416 CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))
2417
2418#define sk_X509_ATTRIBUTE_find(sk, out_index, p) \
2419 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \
2420 CHECKED_CAST(void *, X509_ATTRIBUTE *, p))
2421
2422#define sk_X509_ATTRIBUTE_shift(sk) \
2423 ((X509_ATTRIBUTE *)sk_shift( \
2424 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))
2425
2426#define sk_X509_ATTRIBUTE_push(sk, p) \
2427 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
2428 CHECKED_CAST(void *, X509_ATTRIBUTE *, p))
2429
2430#define sk_X509_ATTRIBUTE_pop(sk) \
2431 ((X509_ATTRIBUTE *)sk_pop( \
2432 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))
2433
2434#define sk_X509_ATTRIBUTE_dup(sk) \
2435 ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \
2436 CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))
2437
2438#define sk_X509_ATTRIBUTE_sort(sk) \
2439 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))
2440
2441#define sk_X509_ATTRIBUTE_is_sorted(sk) \
2442 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))
2443
2444#define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp) \
2445 ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b)) \
2446 sk_set_cmp_func( \
2447 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
2448 CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a, \
2449 const X509_ATTRIBUTE **b), \
2450 comp)))
2451
2452/* X509_CRL */
2453#define sk_X509_CRL_new(comp) \
2454 ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \
2455 stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))
2456
2457#define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null())
2458
2459#define sk_X509_CRL_num(sk) \
2460 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))
2461
2462#define sk_X509_CRL_zero(sk) \
2463 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));
2464
2465#define sk_X509_CRL_value(sk, i) \
2466 ((X509_CRL *)sk_value( \
2467 CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk), (i)))
2468
2469#define sk_X509_CRL_set(sk, i, p) \
2470 ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \
2471 CHECKED_CAST(void *, X509_CRL *, p)))
2472
2473#define sk_X509_CRL_free(sk) \
2474 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))
2475
2476#define sk_X509_CRL_pop_free(sk, free_func) \
2477 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2478 CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))
2479
2480#define sk_X509_CRL_insert(sk, p, where) \
2481 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2482 CHECKED_CAST(void *, X509_CRL *, p), (where))
2483
2484#define sk_X509_CRL_delete(sk, where) \
2485 ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2486 (where)))
2487
2488#define sk_X509_CRL_delete_ptr(sk, p) \
2489 ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2490 CHECKED_CAST(void *, X509_CRL *, p)))
2491
2492#define sk_X509_CRL_find(sk, out_index, p) \
2493 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \
2494 CHECKED_CAST(void *, X509_CRL *, p))
2495
2496#define sk_X509_CRL_shift(sk) \
2497 ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))
2498
2499#define sk_X509_CRL_push(sk, p) \
2500 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2501 CHECKED_CAST(void *, X509_CRL *, p))
2502
2503#define sk_X509_CRL_pop(sk) \
2504 ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))
2505
2506#define sk_X509_CRL_dup(sk) \
2507 ((STACK_OF(X509_CRL) *)sk_dup( \
2508 CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk)))
2509
2510#define sk_X509_CRL_sort(sk) \
2511 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))
2512
2513#define sk_X509_CRL_is_sorted(sk) \
2514 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk))
2515
2516#define sk_X509_CRL_set_cmp_func(sk, comp) \
2517 ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \
2518 CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
2519 CHECKED_CAST(stack_cmp_func, \
2520 int (*)(const X509_CRL **a, const X509_CRL **b), comp)))
2521
2522/* X509_EXTENSION */
2523#define sk_X509_EXTENSION_new(comp) \
2524 ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \
2525 stack_cmp_func, \
2526 int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))
2527
2528#define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null())
2529
2530#define sk_X509_EXTENSION_num(sk) \
2531 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))
2532
2533#define sk_X509_EXTENSION_zero(sk) \
2534 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));
2535
2536#define sk_X509_EXTENSION_value(sk, i) \
2537 ((X509_EXTENSION *)sk_value( \
2538 CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk), (i)))
2539
2540#define sk_X509_EXTENSION_set(sk, i, p) \
2541 ((X509_EXTENSION *)sk_set( \
2542 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \
2543 CHECKED_CAST(void *, X509_EXTENSION *, p)))
2544
2545#define sk_X509_EXTENSION_free(sk) \
2546 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))
2547
2548#define sk_X509_EXTENSION_pop_free(sk, free_func) \
2549 sk_pop_free( \
2550 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
2551 CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))
2552
2553#define sk_X509_EXTENSION_insert(sk, p, where) \
2554 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
2555 CHECKED_CAST(void *, X509_EXTENSION *, p), (where))
2556
2557#define sk_X509_EXTENSION_delete(sk, where) \
2558 ((X509_EXTENSION *)sk_delete( \
2559 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))
2560
2561#define sk_X509_EXTENSION_delete_ptr(sk, p) \
2562 ((X509_EXTENSION *)sk_delete_ptr( \
2563 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
2564 CHECKED_CAST(void *, X509_EXTENSION *, p)))
2565
2566#define sk_X509_EXTENSION_find(sk, out_index, p) \
2567 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \
2568 CHECKED_CAST(void *, X509_EXTENSION *, p))
2569
2570#define sk_X509_EXTENSION_shift(sk) \
2571 ((X509_EXTENSION *)sk_shift( \
2572 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))
2573
2574#define sk_X509_EXTENSION_push(sk, p) \
2575 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
2576 CHECKED_CAST(void *, X509_EXTENSION *, p))
2577
2578#define sk_X509_EXTENSION_pop(sk) \
2579 ((X509_EXTENSION *)sk_pop( \
2580 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))
2581
2582#define sk_X509_EXTENSION_dup(sk) \
2583 ((STACK_OF(X509_EXTENSION) *)sk_dup( \
2584 CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk)))
2585
2586#define sk_X509_EXTENSION_sort(sk) \
2587 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))
2588
2589#define sk_X509_EXTENSION_is_sorted(sk) \
2590 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk))
2591
2592#define sk_X509_EXTENSION_set_cmp_func(sk, comp) \
2593 ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b)) \
2594 sk_set_cmp_func( \
2595 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
2596 CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a, \
2597 const X509_EXTENSION **b), \
2598 comp)))
2599
2600/* X509_INFO */
2601#define sk_X509_INFO_new(comp) \
2602 ((STACK_OF(X509_INFO) *)sk_new( \
2603 CHECKED_CAST(stack_cmp_func, \
2604 int (*)(const X509_INFO **a, const X509_INFO **b), comp)))
2605
2606#define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null())
2607
2608#define sk_X509_INFO_num(sk) \
2609 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))
2610
2611#define sk_X509_INFO_zero(sk) \
2612 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));
2613
2614#define sk_X509_INFO_value(sk, i) \
2615 ((X509_INFO *)sk_value( \
2616 CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk), (i)))
2617
2618#define sk_X509_INFO_set(sk, i, p) \
2619 ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \
2620 CHECKED_CAST(void *, X509_INFO *, p)))
2621
2622#define sk_X509_INFO_free(sk) \
2623 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))
2624
2625#define sk_X509_INFO_pop_free(sk, free_func) \
2626 sk_pop_free( \
2627 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2628 CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))
2629
2630#define sk_X509_INFO_insert(sk, p, where) \
2631 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2632 CHECKED_CAST(void *, X509_INFO *, p), (where))
2633
2634#define sk_X509_INFO_delete(sk, where) \
2635 ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2636 (where)))
2637
2638#define sk_X509_INFO_delete_ptr(sk, p) \
2639 ((X509_INFO *)sk_delete_ptr( \
2640 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2641 CHECKED_CAST(void *, X509_INFO *, p)))
2642
2643#define sk_X509_INFO_find(sk, out_index, p) \
2644 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \
2645 CHECKED_CAST(void *, X509_INFO *, p))
2646
2647#define sk_X509_INFO_shift(sk) \
2648 ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))
2649
2650#define sk_X509_INFO_push(sk, p) \
2651 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2652 CHECKED_CAST(void *, X509_INFO *, p))
2653
2654#define sk_X509_INFO_pop(sk) \
2655 ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))
2656
2657#define sk_X509_INFO_dup(sk) \
2658 ((STACK_OF(X509_INFO) *)sk_dup( \
2659 CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk)))
2660
2661#define sk_X509_INFO_sort(sk) \
2662 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))
2663
2664#define sk_X509_INFO_is_sorted(sk) \
2665 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk))
2666
2667#define sk_X509_INFO_set_cmp_func(sk, comp) \
2668 ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \
2669 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
2670 CHECKED_CAST(stack_cmp_func, \
2671 int (*)(const X509_INFO **a, const X509_INFO **b), comp)))
2672
2673/* X509_LOOKUP */
2674#define sk_X509_LOOKUP_new(comp) \
2675 ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST( \
2676 stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \
2677 comp)))
2678
2679#define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null())
2680
2681#define sk_X509_LOOKUP_num(sk) \
2682 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))
2683
2684#define sk_X509_LOOKUP_zero(sk) \
2685 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));
2686
2687#define sk_X509_LOOKUP_value(sk, i) \
2688 ((X509_LOOKUP *)sk_value( \
2689 CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))
2690
2691#define sk_X509_LOOKUP_set(sk, i, p) \
2692 ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2693 (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))
2694
2695#define sk_X509_LOOKUP_free(sk) \
2696 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))
2697
2698#define sk_X509_LOOKUP_pop_free(sk, free_func) \
2699 sk_pop_free( \
2700 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2701 CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))
2702
2703#define sk_X509_LOOKUP_insert(sk, p, where) \
2704 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2705 CHECKED_CAST(void *, X509_LOOKUP *, p), (where))
2706
2707#define sk_X509_LOOKUP_delete(sk, where) \
2708 ((X509_LOOKUP *)sk_delete( \
2709 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))
2710
2711#define sk_X509_LOOKUP_delete_ptr(sk, p) \
2712 ((X509_LOOKUP *)sk_delete_ptr( \
2713 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2714 CHECKED_CAST(void *, X509_LOOKUP *, p)))
2715
2716#define sk_X509_LOOKUP_find(sk, out_index, p) \
2717 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \
2718 CHECKED_CAST(void *, X509_LOOKUP *, p))
2719
2720#define sk_X509_LOOKUP_shift(sk) \
2721 ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))
2722
2723#define sk_X509_LOOKUP_push(sk, p) \
2724 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2725 CHECKED_CAST(void *, X509_LOOKUP *, p))
2726
2727#define sk_X509_LOOKUP_pop(sk) \
2728 ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))
2729
2730#define sk_X509_LOOKUP_dup(sk) \
2731 ((STACK_OF(X509_LOOKUP) *)sk_dup( \
2732 CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk)))
2733
2734#define sk_X509_LOOKUP_sort(sk) \
2735 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))
2736
2737#define sk_X509_LOOKUP_is_sorted(sk) \
2738 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk))
2739
2740#define sk_X509_LOOKUP_set_cmp_func(sk, comp) \
2741 ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \
2742 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
2743 CHECKED_CAST(stack_cmp_func, \
2744 int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \
2745 comp)))
2746
2747/* X509_NAME */
2748#define sk_X509_NAME_new(comp) \
2749 ((STACK_OF(X509_NAME) *)sk_new( \
2750 CHECKED_CAST(stack_cmp_func, \
2751 int (*)(const X509_NAME **a, const X509_NAME **b), comp)))
2752
2753#define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null())
2754
2755#define sk_X509_NAME_num(sk) \
2756 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))
2757
2758#define sk_X509_NAME_zero(sk) \
2759 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));
2760
2761#define sk_X509_NAME_value(sk, i) \
2762 ((X509_NAME *)sk_value( \
2763 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk), (i)))
2764
2765#define sk_X509_NAME_set(sk, i, p) \
2766 ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \
2767 CHECKED_CAST(void *, X509_NAME *, p)))
2768
2769#define sk_X509_NAME_free(sk) \
2770 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))
2771
2772#define sk_X509_NAME_pop_free(sk, free_func) \
2773 sk_pop_free( \
2774 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2775 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))
2776
2777#define sk_X509_NAME_insert(sk, p, where) \
2778 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2779 CHECKED_CAST(void *, X509_NAME *, p), (where))
2780
2781#define sk_X509_NAME_delete(sk, where) \
2782 ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2783 (where)))
2784
2785#define sk_X509_NAME_delete_ptr(sk, p) \
2786 ((X509_NAME *)sk_delete_ptr( \
2787 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2788 CHECKED_CAST(void *, X509_NAME *, p)))
2789
2790#define sk_X509_NAME_find(sk, out_index, p) \
2791 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \
2792 CHECKED_CAST(void *, X509_NAME *, p))
2793
2794#define sk_X509_NAME_shift(sk) \
2795 ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))
2796
2797#define sk_X509_NAME_push(sk, p) \
2798 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2799 CHECKED_CAST(void *, X509_NAME *, p))
2800
2801#define sk_X509_NAME_pop(sk) \
2802 ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))
2803
2804#define sk_X509_NAME_dup(sk) \
2805 ((STACK_OF(X509_NAME) *)sk_dup( \
2806 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk)))
2807
2808#define sk_X509_NAME_sort(sk) \
2809 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))
2810
2811#define sk_X509_NAME_is_sorted(sk) \
2812 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk))
2813
2814#define sk_X509_NAME_set_cmp_func(sk, comp) \
2815 ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \
2816 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
2817 CHECKED_CAST(stack_cmp_func, \
2818 int (*)(const X509_NAME **a, const X509_NAME **b), comp)))
2819
2820/* X509_NAME_ENTRY */
2821#define sk_X509_NAME_ENTRY_new(comp) \
2822 ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \
2823 stack_cmp_func, \
2824 int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))
2825
2826#define sk_X509_NAME_ENTRY_new_null() \
2827 ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())
2828
2829#define sk_X509_NAME_ENTRY_num(sk) \
2830 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2831
2832#define sk_X509_NAME_ENTRY_zero(sk) \
2833 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));
2834
2835#define sk_X509_NAME_ENTRY_value(sk, i) \
2836 ((X509_NAME_ENTRY *)sk_value( \
2837 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), (i)))
2838
2839#define sk_X509_NAME_ENTRY_set(sk, i, p) \
2840 ((X509_NAME_ENTRY *)sk_set( \
2841 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \
2842 CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))
2843
2844#define sk_X509_NAME_ENTRY_free(sk) \
2845 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2846
2847#define sk_X509_NAME_ENTRY_pop_free(sk, free_func) \
2848 sk_pop_free( \
2849 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2850 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))
2851
2852#define sk_X509_NAME_ENTRY_insert(sk, p, where) \
2853 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2854 CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))
2855
2856#define sk_X509_NAME_ENTRY_delete(sk, where) \
2857 ((X509_NAME_ENTRY *)sk_delete( \
2858 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))
2859
2860#define sk_X509_NAME_ENTRY_delete_ptr(sk, p) \
2861 ((X509_NAME_ENTRY *)sk_delete_ptr( \
2862 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2863 CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))
2864
2865#define sk_X509_NAME_ENTRY_find(sk, out_index, p) \
2866 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2867 (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))
2868
2869#define sk_X509_NAME_ENTRY_shift(sk) \
2870 ((X509_NAME_ENTRY *)sk_shift( \
2871 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))
2872
2873#define sk_X509_NAME_ENTRY_push(sk, p) \
2874 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2875 CHECKED_CAST(void *, X509_NAME_ENTRY *, p))
2876
2877#define sk_X509_NAME_ENTRY_pop(sk) \
2878 ((X509_NAME_ENTRY *)sk_pop( \
2879 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))
2880
2881#define sk_X509_NAME_ENTRY_dup(sk) \
2882 ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \
2883 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))
2884
2885#define sk_X509_NAME_ENTRY_sort(sk) \
2886 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2887
2888#define sk_X509_NAME_ENTRY_is_sorted(sk) \
2889 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))
2890
2891#define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp) \
2892 ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b)) \
2893 sk_set_cmp_func( \
2894 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2895 CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a, \
2896 const X509_NAME_ENTRY **b), \
2897 comp)))
2898
2899/* X509_NAME_ENTRY */
2900#define sk_X509_NAME_ENTRY_new(comp) \
2901 ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \
2902 stack_cmp_func, \
2903 int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))
2904
2905#define sk_X509_NAME_ENTRY_new_null() \
2906 ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())
2907
2908#define sk_X509_NAME_ENTRY_num(sk) \
2909 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2910
2911#define sk_X509_NAME_ENTRY_zero(sk) \
2912 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));
2913
2914#define sk_X509_NAME_ENTRY_value(sk, i) \
2915 ((X509_NAME_ENTRY *)sk_value( \
2916 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), (i)))
2917
2918#define sk_X509_NAME_ENTRY_set(sk, i, p) \
2919 ((X509_NAME_ENTRY *)sk_set( \
2920 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \
2921 CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))
2922
2923#define sk_X509_NAME_ENTRY_free(sk) \
2924 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2925
2926#define sk_X509_NAME_ENTRY_pop_free(sk, free_func) \
2927 sk_pop_free( \
2928 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2929 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))
2930
2931#define sk_X509_NAME_ENTRY_insert(sk, p, where) \
2932 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2933 CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))
2934
2935#define sk_X509_NAME_ENTRY_delete(sk, where) \
2936 ((X509_NAME_ENTRY *)sk_delete( \
2937 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))
2938
2939#define sk_X509_NAME_ENTRY_delete_ptr(sk, p) \
2940 ((X509_NAME_ENTRY *)sk_delete_ptr( \
2941 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2942 CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))
2943
2944#define sk_X509_NAME_ENTRY_find(sk, out_index, p) \
2945 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2946 (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))
2947
2948#define sk_X509_NAME_ENTRY_shift(sk) \
2949 ((X509_NAME_ENTRY *)sk_shift( \
2950 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))
2951
2952#define sk_X509_NAME_ENTRY_push(sk, p) \
2953 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2954 CHECKED_CAST(void *, X509_NAME_ENTRY *, p))
2955
2956#define sk_X509_NAME_ENTRY_pop(sk) \
2957 ((X509_NAME_ENTRY *)sk_pop( \
2958 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))
2959
2960#define sk_X509_NAME_ENTRY_dup(sk) \
2961 ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \
2962 CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))
2963
2964#define sk_X509_NAME_ENTRY_sort(sk) \
2965 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
2966
2967#define sk_X509_NAME_ENTRY_is_sorted(sk) \
2968 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))
2969
2970#define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp) \
2971 ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b)) \
2972 sk_set_cmp_func( \
2973 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
2974 CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a, \
2975 const X509_NAME_ENTRY **b), \
2976 comp)))
2977
2978/* X509_OBJECT */
2979#define sk_X509_OBJECT_new(comp) \
2980 ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST( \
2981 stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \
2982 comp)))
2983
2984#define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null())
2985
2986#define sk_X509_OBJECT_num(sk) \
2987 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))
2988
2989#define sk_X509_OBJECT_zero(sk) \
2990 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));
2991
2992#define sk_X509_OBJECT_value(sk, i) \
2993 ((X509_OBJECT *)sk_value( \
2994 CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))
2995
2996#define sk_X509_OBJECT_set(sk, i, p) \
2997 ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
2998 (i), CHECKED_CAST(void *, X509_OBJECT *, p)))
2999
3000#define sk_X509_OBJECT_free(sk) \
3001 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))
3002
3003#define sk_X509_OBJECT_pop_free(sk, free_func) \
3004 sk_pop_free( \
3005 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
3006 CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))
3007
3008#define sk_X509_OBJECT_insert(sk, p, where) \
3009 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
3010 CHECKED_CAST(void *, X509_OBJECT *, p), (where))
3011
3012#define sk_X509_OBJECT_delete(sk, where) \
3013 ((X509_OBJECT *)sk_delete( \
3014 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))
3015
3016#define sk_X509_OBJECT_delete_ptr(sk, p) \
3017 ((X509_OBJECT *)sk_delete_ptr( \
3018 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
3019 CHECKED_CAST(void *, X509_OBJECT *, p)))
3020
3021#define sk_X509_OBJECT_find(sk, out_index, p) \
3022 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \
3023 CHECKED_CAST(void *, X509_OBJECT *, p))
3024
3025#define sk_X509_OBJECT_shift(sk) \
3026 ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))
3027
3028#define sk_X509_OBJECT_push(sk, p) \
3029 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
3030 CHECKED_CAST(void *, X509_OBJECT *, p))
3031
3032#define sk_X509_OBJECT_pop(sk) \
3033 ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))
3034
3035#define sk_X509_OBJECT_dup(sk) \
3036 ((STACK_OF(X509_OBJECT) *)sk_dup( \
3037 CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk)))
3038
3039#define sk_X509_OBJECT_sort(sk) \
3040 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))
3041
3042#define sk_X509_OBJECT_is_sorted(sk) \
3043 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk))
3044
3045#define sk_X509_OBJECT_set_cmp_func(sk, comp) \
3046 ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \
3047 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
3048 CHECKED_CAST(stack_cmp_func, \
3049 int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \
3050 comp)))
3051
3052/* X509_POLICY_DATA */
3053#define sk_X509_POLICY_DATA_new(comp) \
3054 ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \
3055 stack_cmp_func, \
3056 int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))
3057
3058#define sk_X509_POLICY_DATA_new_null() \
3059 ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())
3060
3061#define sk_X509_POLICY_DATA_num(sk) \
3062 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))
3063
3064#define sk_X509_POLICY_DATA_zero(sk) \
3065 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));
3066
3067#define sk_X509_POLICY_DATA_value(sk, i) \
3068 ((X509_POLICY_DATA *)sk_value( \
3069 CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), (i)))
3070
3071#define sk_X509_POLICY_DATA_set(sk, i, p) \
3072 ((X509_POLICY_DATA *)sk_set( \
3073 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \
3074 CHECKED_CAST(void *, X509_POLICY_DATA *, p)))
3075
3076#define sk_X509_POLICY_DATA_free(sk) \
3077 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))
3078
3079#define sk_X509_POLICY_DATA_pop_free(sk, free_func) \
3080 sk_pop_free( \
3081 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3082 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))
3083
3084#define sk_X509_POLICY_DATA_insert(sk, p, where) \
3085 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3086 CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))
3087
3088#define sk_X509_POLICY_DATA_delete(sk, where) \
3089 ((X509_POLICY_DATA *)sk_delete( \
3090 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))
3091
3092#define sk_X509_POLICY_DATA_delete_ptr(sk, p) \
3093 ((X509_POLICY_DATA *)sk_delete_ptr( \
3094 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3095 CHECKED_CAST(void *, X509_POLICY_DATA *, p)))
3096
3097#define sk_X509_POLICY_DATA_find(sk, out_index, p) \
3098 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3099 (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))
3100
3101#define sk_X509_POLICY_DATA_shift(sk) \
3102 ((X509_POLICY_DATA *)sk_shift( \
3103 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))
3104
3105#define sk_X509_POLICY_DATA_push(sk, p) \
3106 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3107 CHECKED_CAST(void *, X509_POLICY_DATA *, p))
3108
3109#define sk_X509_POLICY_DATA_pop(sk) \
3110 ((X509_POLICY_DATA *)sk_pop( \
3111 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))
3112
3113#define sk_X509_POLICY_DATA_dup(sk) \
3114 ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \
3115 CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))
3116
3117#define sk_X509_POLICY_DATA_sort(sk) \
3118 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))
3119
3120#define sk_X509_POLICY_DATA_is_sorted(sk) \
3121 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))
3122
3123#define sk_X509_POLICY_DATA_set_cmp_func(sk, comp) \
3124 ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b)) \
3125 sk_set_cmp_func( \
3126 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
3127 CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a, \
3128 const X509_POLICY_DATA **b), \
3129 comp)))
3130
3131/* X509_POLICY_NODE */
3132#define sk_X509_POLICY_NODE_new(comp) \
3133 ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \
3134 stack_cmp_func, \
3135 int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))
3136
3137#define sk_X509_POLICY_NODE_new_null() \
3138 ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())
3139
3140#define sk_X509_POLICY_NODE_num(sk) \
3141 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))
3142
3143#define sk_X509_POLICY_NODE_zero(sk) \
3144 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));
3145
3146#define sk_X509_POLICY_NODE_value(sk, i) \
3147 ((X509_POLICY_NODE *)sk_value( \
3148 CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), (i)))
3149
3150#define sk_X509_POLICY_NODE_set(sk, i, p) \
3151 ((X509_POLICY_NODE *)sk_set( \
3152 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \
3153 CHECKED_CAST(void *, X509_POLICY_NODE *, p)))
3154
3155#define sk_X509_POLICY_NODE_free(sk) \
3156 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))
3157
3158#define sk_X509_POLICY_NODE_pop_free(sk, free_func) \
3159 sk_pop_free( \
3160 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3161 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))
3162
3163#define sk_X509_POLICY_NODE_insert(sk, p, where) \
3164 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3165 CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))
3166
3167#define sk_X509_POLICY_NODE_delete(sk, where) \
3168 ((X509_POLICY_NODE *)sk_delete( \
3169 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))
3170
3171#define sk_X509_POLICY_NODE_delete_ptr(sk, p) \
3172 ((X509_POLICY_NODE *)sk_delete_ptr( \
3173 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3174 CHECKED_CAST(void *, X509_POLICY_NODE *, p)))
3175
3176#define sk_X509_POLICY_NODE_find(sk, out_index, p) \
3177 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3178 (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))
3179
3180#define sk_X509_POLICY_NODE_shift(sk) \
3181 ((X509_POLICY_NODE *)sk_shift( \
3182 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))
3183
3184#define sk_X509_POLICY_NODE_push(sk, p) \
3185 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3186 CHECKED_CAST(void *, X509_POLICY_NODE *, p))
3187
3188#define sk_X509_POLICY_NODE_pop(sk) \
3189 ((X509_POLICY_NODE *)sk_pop( \
3190 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))
3191
3192#define sk_X509_POLICY_NODE_dup(sk) \
3193 ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \
3194 CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))
3195
3196#define sk_X509_POLICY_NODE_sort(sk) \
3197 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))
3198
3199#define sk_X509_POLICY_NODE_is_sorted(sk) \
3200 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))
3201
3202#define sk_X509_POLICY_NODE_set_cmp_func(sk, comp) \
3203 ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b)) \
3204 sk_set_cmp_func( \
3205 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
3206 CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a, \
3207 const X509_POLICY_NODE **b), \
3208 comp)))
3209
3210/* X509_PURPOSE */
3211#define sk_X509_PURPOSE_new(comp) \
3212 ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST( \
3213 stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \
3214 comp)))
3215
3216#define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null())
3217
3218#define sk_X509_PURPOSE_num(sk) \
3219 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))
3220
3221#define sk_X509_PURPOSE_zero(sk) \
3222 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));
3223
3224#define sk_X509_PURPOSE_value(sk, i) \
3225 ((X509_PURPOSE *)sk_value( \
3226 CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))
3227
3228#define sk_X509_PURPOSE_set(sk, i, p) \
3229 ((X509_PURPOSE *)sk_set( \
3230 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \
3231 CHECKED_CAST(void *, X509_PURPOSE *, p)))
3232
3233#define sk_X509_PURPOSE_free(sk) \
3234 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))
3235
3236#define sk_X509_PURPOSE_pop_free(sk, free_func) \
3237 sk_pop_free( \
3238 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
3239 CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))
3240
3241#define sk_X509_PURPOSE_insert(sk, p, where) \
3242 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
3243 CHECKED_CAST(void *, X509_PURPOSE *, p), (where))
3244
3245#define sk_X509_PURPOSE_delete(sk, where) \
3246 ((X509_PURPOSE *)sk_delete( \
3247 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))
3248
3249#define sk_X509_PURPOSE_delete_ptr(sk, p) \
3250 ((X509_PURPOSE *)sk_delete_ptr( \
3251 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
3252 CHECKED_CAST(void *, X509_PURPOSE *, p)))
3253
3254#define sk_X509_PURPOSE_find(sk, out_index, p) \
3255 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \
3256 CHECKED_CAST(void *, X509_PURPOSE *, p))
3257
3258#define sk_X509_PURPOSE_shift(sk) \
3259 ((X509_PURPOSE *)sk_shift( \
3260 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))
3261
3262#define sk_X509_PURPOSE_push(sk, p) \
3263 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
3264 CHECKED_CAST(void *, X509_PURPOSE *, p))
3265
3266#define sk_X509_PURPOSE_pop(sk) \
3267 ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))
3268
3269#define sk_X509_PURPOSE_dup(sk) \
3270 ((STACK_OF(X509_PURPOSE) *)sk_dup( \
3271 CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk)))
3272
3273#define sk_X509_PURPOSE_sort(sk) \
3274 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))
3275
3276#define sk_X509_PURPOSE_is_sorted(sk) \
3277 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk))
3278
3279#define sk_X509_PURPOSE_set_cmp_func(sk, comp) \
3280 ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \
3281 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
3282 CHECKED_CAST(stack_cmp_func, \
3283 int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \
3284 comp)))
3285
3286/* X509_REVOKED */
3287#define sk_X509_REVOKED_new(comp) \
3288 ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST( \
3289 stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \
3290 comp)))
3291
3292#define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null())
3293
3294#define sk_X509_REVOKED_num(sk) \
3295 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))
3296
3297#define sk_X509_REVOKED_zero(sk) \
3298 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));
3299
3300#define sk_X509_REVOKED_value(sk, i) \
3301 ((X509_REVOKED *)sk_value( \
3302 CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))
3303
3304#define sk_X509_REVOKED_set(sk, i, p) \
3305 ((X509_REVOKED *)sk_set( \
3306 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \
3307 CHECKED_CAST(void *, X509_REVOKED *, p)))
3308
3309#define sk_X509_REVOKED_free(sk) \
3310 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))
3311
3312#define sk_X509_REVOKED_pop_free(sk, free_func) \
3313 sk_pop_free( \
3314 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
3315 CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))
3316
3317#define sk_X509_REVOKED_insert(sk, p, where) \
3318 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
3319 CHECKED_CAST(void *, X509_REVOKED *, p), (where))
3320
3321#define sk_X509_REVOKED_delete(sk, where) \
3322 ((X509_REVOKED *)sk_delete( \
3323 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))
3324
3325#define sk_X509_REVOKED_delete_ptr(sk, p) \
3326 ((X509_REVOKED *)sk_delete_ptr( \
3327 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
3328 CHECKED_CAST(void *, X509_REVOKED *, p)))
3329
3330#define sk_X509_REVOKED_find(sk, out_index, p) \
3331 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \
3332 CHECKED_CAST(void *, X509_REVOKED *, p))
3333
3334#define sk_X509_REVOKED_shift(sk) \
3335 ((X509_REVOKED *)sk_shift( \
3336 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))
3337
3338#define sk_X509_REVOKED_push(sk, p) \
3339 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
3340 CHECKED_CAST(void *, X509_REVOKED *, p))
3341
3342#define sk_X509_REVOKED_pop(sk) \
3343 ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))
3344
3345#define sk_X509_REVOKED_dup(sk) \
3346 ((STACK_OF(X509_REVOKED) *)sk_dup( \
3347 CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk)))
3348
3349#define sk_X509_REVOKED_sort(sk) \
3350 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))
3351
3352#define sk_X509_REVOKED_is_sorted(sk) \
3353 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk))
3354
3355#define sk_X509_REVOKED_set_cmp_func(sk, comp) \
3356 ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \
3357 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
3358 CHECKED_CAST(stack_cmp_func, \
3359 int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \
3360 comp)))
3361
3362/* X509_TRUST */
3363#define sk_X509_TRUST_new(comp) \
3364 ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST( \
3365 stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \
3366 comp)))
3367
3368#define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null())
3369
3370#define sk_X509_TRUST_num(sk) \
3371 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))
3372
3373#define sk_X509_TRUST_zero(sk) \
3374 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));
3375
3376#define sk_X509_TRUST_value(sk, i) \
3377 ((X509_TRUST *)sk_value( \
3378 CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))
3379
3380#define sk_X509_TRUST_set(sk, i, p) \
3381 ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3382 (i), CHECKED_CAST(void *, X509_TRUST *, p)))
3383
3384#define sk_X509_TRUST_free(sk) \
3385 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))
3386
3387#define sk_X509_TRUST_pop_free(sk, free_func) \
3388 sk_pop_free( \
3389 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3390 CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))
3391
3392#define sk_X509_TRUST_insert(sk, p, where) \
3393 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3394 CHECKED_CAST(void *, X509_TRUST *, p), (where))
3395
3396#define sk_X509_TRUST_delete(sk, where) \
3397 ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3398 (where)))
3399
3400#define sk_X509_TRUST_delete_ptr(sk, p) \
3401 ((X509_TRUST *)sk_delete_ptr( \
3402 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3403 CHECKED_CAST(void *, X509_TRUST *, p)))
3404
3405#define sk_X509_TRUST_find(sk, out_index, p) \
3406 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \
3407 CHECKED_CAST(void *, X509_TRUST *, p))
3408
3409#define sk_X509_TRUST_shift(sk) \
3410 ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))
3411
3412#define sk_X509_TRUST_push(sk, p) \
3413 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3414 CHECKED_CAST(void *, X509_TRUST *, p))
3415
3416#define sk_X509_TRUST_pop(sk) \
3417 ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))
3418
3419#define sk_X509_TRUST_dup(sk) \
3420 ((STACK_OF(X509_TRUST) *)sk_dup( \
3421 CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk)))
3422
3423#define sk_X509_TRUST_sort(sk) \
3424 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))
3425
3426#define sk_X509_TRUST_is_sorted(sk) \
3427 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk))
3428
3429#define sk_X509_TRUST_set_cmp_func(sk, comp) \
3430 ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \
3431 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
3432 CHECKED_CAST(stack_cmp_func, \
3433 int (*)(const X509_TRUST **a, const X509_TRUST **b), \
3434 comp)))
3435
3436/* X509_VERIFY_PARAM */
3437#define sk_X509_VERIFY_PARAM_new(comp) \
3438 ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST( \
3439 stack_cmp_func, \
3440 int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \
3441 comp)))
3442
3443#define sk_X509_VERIFY_PARAM_new_null() \
3444 ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())
3445
3446#define sk_X509_VERIFY_PARAM_num(sk) \
3447 sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))
3448
3449#define sk_X509_VERIFY_PARAM_zero(sk) \
3450 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));
3451
3452#define sk_X509_VERIFY_PARAM_value(sk, i) \
3453 ((X509_VERIFY_PARAM *)sk_value( \
3454 CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), (i)))
3455
3456#define sk_X509_VERIFY_PARAM_set(sk, i, p) \
3457 ((X509_VERIFY_PARAM *)sk_set( \
3458 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \
3459 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))
3460
3461#define sk_X509_VERIFY_PARAM_free(sk) \
3462 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))
3463
3464#define sk_X509_VERIFY_PARAM_pop_free(sk, free_func) \
3465 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3466 CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \
3467 free_func))
3468
3469#define sk_X509_VERIFY_PARAM_insert(sk, p, where) \
3470 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3471 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))
3472
3473#define sk_X509_VERIFY_PARAM_delete(sk, where) \
3474 ((X509_VERIFY_PARAM *)sk_delete( \
3475 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))
3476
3477#define sk_X509_VERIFY_PARAM_delete_ptr(sk, p) \
3478 ((X509_VERIFY_PARAM *)sk_delete_ptr( \
3479 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3480 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))
3481
3482#define sk_X509_VERIFY_PARAM_find(sk, out_index, p) \
3483 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3484 (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))
3485
3486#define sk_X509_VERIFY_PARAM_shift(sk) \
3487 ((X509_VERIFY_PARAM *)sk_shift( \
3488 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))
3489
3490#define sk_X509_VERIFY_PARAM_push(sk, p) \
3491 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3492 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))
3493
3494#define sk_X509_VERIFY_PARAM_pop(sk) \
3495 ((X509_VERIFY_PARAM *)sk_pop( \
3496 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))
3497
3498#define sk_X509_VERIFY_PARAM_dup(sk) \
3499 ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \
3500 CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))
3501
3502#define sk_X509_VERIFY_PARAM_sort(sk) \
3503 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))
3504
3505#define sk_X509_VERIFY_PARAM_is_sorted(sk) \
3506 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))
3507
3508#define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp) \
3509 ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b)) \
3510 sk_set_cmp_func( \
3511 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
3512 CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a, \
3513 const X509_VERIFY_PARAM **b), \
3514 comp)))
3515
3516/* void */
3517#define sk_void_new(comp) \
3518 ((STACK_OF(void)*)sk_new(CHECKED_CAST( \
3519 stack_cmp_func, int (*)(const void **a, const void **b), comp)))
3520
3521#define sk_void_new_null() ((STACK_OF(void)*)sk_new_null())
3522
3523#define sk_void_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))
3524
3525#define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk));
3526
3527#define sk_void_value(sk, i) \
3528 ((void *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk), (i)))
3529
3530#define sk_void_set(sk, i, p) \
3531 ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (i), \
3532 CHECKED_CAST(void *, void *, p)))
3533
3534#define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))
3535
3536#define sk_void_pop_free(sk, free_func) \
3537 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \
3538 CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))
3539
3540#define sk_void_insert(sk, p, where) \
3541 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \
3542 CHECKED_CAST(void *, void *, p), (where))
3543
3544#define sk_void_delete(sk, where) \
3545 ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (where)))
3546
3547#define sk_void_delete_ptr(sk, p) \
3548 ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \
3549 CHECKED_CAST(void *, void *, p)))
3550
3551#define sk_void_find(sk, out_index, p) \
3552 sk_find(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (out_index), \
3553 CHECKED_CAST(void *, void *, p))
3554
3555#define sk_void_shift(sk) \
3556 ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))
3557
3558#define sk_void_push(sk, p) \
3559 sk_push(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \
3560 CHECKED_CAST(void *, void *, p))
3561
3562#define sk_void_pop(sk) \
3563 ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))
3564
3565#define sk_void_dup(sk) \
3566 ((STACK_OF(void)*)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk)))
3567
3568#define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))
3569
3570#define sk_void_is_sorted(sk) \
3571 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk))
3572
3573#define sk_void_set_cmp_func(sk, comp) \
3574 ((int (*)(const void **a, const void **b))sk_set_cmp_func( \
3575 CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \
3576 CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \
3577 comp)))
3578
3579/* OPENSSL_STRING */
3580#define sk_OPENSSL_STRING_new(comp) \
3581 ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \
3582 stack_cmp_func, \
3583 int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))
3584
3585#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())
3586
3587#define sk_OPENSSL_STRING_num(sk) \
3588 sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))
3589
3590#define sk_OPENSSL_STRING_zero(sk) \
3591 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));
3592
3593#define sk_OPENSSL_STRING_value(sk, i) \
3594 ((OPENSSL_STRING)sk_value( \
3595 CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk), (i)))
3596
3597#define sk_OPENSSL_STRING_set(sk, i, p) \
3598 ((OPENSSL_STRING)sk_set( \
3599 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \
3600 CHECKED_CAST(void *, OPENSSL_STRING, p)))
3601
3602#define sk_OPENSSL_STRING_free(sk) \
3603 sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))
3604
3605#define sk_OPENSSL_STRING_pop_free(sk, free_func) \
3606 sk_pop_free( \
3607 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
3608 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))
3609
3610#define sk_OPENSSL_STRING_insert(sk, p, where) \
3611 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
3612 CHECKED_CAST(void *, OPENSSL_STRING, p), (where))
3613
3614#define sk_OPENSSL_STRING_delete(sk, where) \
3615 ((OPENSSL_STRING)sk_delete( \
3616 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))
3617
3618#define sk_OPENSSL_STRING_delete_ptr(sk, p) \
3619 ((OPENSSL_STRING)sk_delete_ptr( \
3620 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
3621 CHECKED_CAST(void *, OPENSSL_STRING, p)))
3622
3623#define sk_OPENSSL_STRING_find(sk, out_index, p) \
3624 sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \
3625 CHECKED_CAST(void *, OPENSSL_STRING, p))
3626
3627#define sk_OPENSSL_STRING_shift(sk) \
3628 ((OPENSSL_STRING)sk_shift( \
3629 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))
3630
3631#define sk_OPENSSL_STRING_push(sk, p) \
3632 sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
3633 CHECKED_CAST(void *, OPENSSL_STRING, p))
3634
3635#define sk_OPENSSL_STRING_pop(sk) \
3636 ((OPENSSL_STRING)sk_pop( \
3637 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))
3638
3639#define sk_OPENSSL_STRING_dup(sk) \
3640 ((STACK_OF(OPENSSL_STRING) *)sk_dup( \
3641 CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))
3642
3643#define sk_OPENSSL_STRING_sort(sk) \
3644 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))
3645
3646#define sk_OPENSSL_STRING_is_sorted(sk) \
3647 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk))
3648
3649#define sk_OPENSSL_STRING_set_cmp_func(sk, comp) \
3650 ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b)) \
3651 sk_set_cmp_func( \
3652 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
3653 CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a, \
3654 const OPENSSL_STRING **b), \
3655 comp)))
3656
3657/* OPENSSL_BLOCK */
3658#define sk_OPENSSL_BLOCK_new(comp) \
3659 ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_CAST( \
3660 stack_cmp_func, int (*)(const OPENSSL_BLOCK *a, const OPENSSL_BLOCK *b), \
3661 comp)))
3662
3663#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())
3664
3665#define sk_OPENSSL_BLOCK_num(sk) \
3666 sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))
3667
3668#define sk_OPENSSL_BLOCK_zero(sk) \
3669 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk));
3670
3671#define sk_OPENSSL_BLOCK_value(sk, i) \
3672 ((OPENSSL_BLOCK)sk_value( \
3673 CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), (i)))
3674
3675#define sk_OPENSSL_BLOCK_set(sk, i, p) \
3676 ((OPENSSL_BLOCK)sk_set( \
3677 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (i), \
3678 CHECKED_CAST(void *, OPENSSL_BLOCK, p)))
3679
3680#define sk_OPENSSL_BLOCK_free(sk) \
3681 sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))
3682
3683#define sk_OPENSSL_BLOCK_pop_free(sk, free_func) \
3684 sk_pop_free( \
3685 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \
3686 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func))
3687
3688#define sk_OPENSSL_BLOCK_insert(sk, p, where) \
3689 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \
3690 CHECKED_CAST(void *, OPENSSL_BLOCK, p), (where))
3691
3692#define sk_OPENSSL_BLOCK_delete(sk, where) \
3693 ((OPENSSL_BLOCK)sk_delete( \
3694 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (where)))
3695
3696#define sk_OPENSSL_BLOCK_delete_ptr(sk, p) \
3697 ((OPENSSL_BLOCK)sk_delete_ptr( \
3698 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \
3699 CHECKED_CAST(void *, OPENSSL_BLOCK, p)))
3700
3701#define sk_OPENSSL_BLOCK_find(sk, out_index, p) \
3702 sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (out_index), \
3703 CHECKED_CAST(void *, OPENSSL_BLOCK, p))
3704
3705#define sk_OPENSSL_BLOCK_shift(sk) \
3706 ((OPENSSL_BLOCK)sk_shift( \
3707 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))
3708
3709#define sk_OPENSSL_BLOCK_push(sk, p) \
3710 sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \
3711 CHECKED_CAST(void *, OPENSSL_BLOCK, p))
3712
3713#define sk_OPENSSL_BLOCK_pop(sk) \
3714 ((OPENSSL_BLOCK)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))
3715
3716#define sk_OPENSSL_BLOCK_dup(sk) \
3717 ((STACK_OF(OPENSSL_BLOCK) *)sk_dup( \
3718 CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)))
3719
3720#define sk_OPENSSL_BLOCK_sort(sk) \
3721 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))
3722
3723#define sk_OPENSSL_BLOCK_is_sorted(sk) \
3724 sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk))
3725
3726#define sk_OPENSSL_BLOCK_set_cmp_func(sk, comp) \
3727 ((int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b))sk_set_cmp_func( \
3728 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \
3729 CHECKED_CAST(stack_cmp_func, \
3730 int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b), \
3731 comp)))