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