kris
/
boringssl
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2553 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tree: a7aa2bb8f8
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'a7aa2bb8f8'
${ noResults }
boringssl/include/openssl/stack_macros.h

3935 regels
179 KiB
Ruw Blame Geschiedenis 

  1. /* Copyright (c) 2014, Google Inc.

  2.  *

  3.  * Permission to use, copy, modify, and/or distribute this software for any

  4.  * purpose with or without fee is hereby granted, provided that the above

  5.  * copyright notice and this permission notice appear in all copies.

  6.  *

  7.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

  8.  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

  9.  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

  10.  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

  11.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

  12.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  13.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */

  14. 

  15. #if !defined(IN_STACK_H)

  16. #error "Don't include this file directly. Include stack.h."

  17. #endif

  18. 

  19. /* ACCESS_DESCRIPTION */

  20. #define sk_ACCESS_DESCRIPTION_new(comp)                                    \

  21.   ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new(CHECKED_CAST(                    \

  22.       stack_cmp_func,                                                      \

  23.       int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b), \

  24.       comp)))

  25. 

  26. #define sk_ACCESS_DESCRIPTION_new_null() \

  27.   ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new_null())

  28. 

  29. #define sk_ACCESS_DESCRIPTION_num(sk) \

  30.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))

  31. 

  32. #define sk_ACCESS_DESCRIPTION_zero(sk) \

  33.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk));

  34. 

  35. #define sk_ACCESS_DESCRIPTION_value(sk, i) \

  36.   ((ACCESS_DESCRIPTION *)sk_value(         \

  37.       CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), (i)))

  38. 

  39. #define sk_ACCESS_DESCRIPTION_set(sk, i, p)                            \

  40.   ((ACCESS_DESCRIPTION *)sk_set(                                       \

  41.       CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (i), \

  42.       CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))

  43. 

  44. #define sk_ACCESS_DESCRIPTION_free(sk) \

  45.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))

  46. 

  47. #define sk_ACCESS_DESCRIPTION_pop_free(sk, free_func)                        \

  48.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk),    \

  49.               CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *), \

  50.                            free_func))

  51. 

  52. #define sk_ACCESS_DESCRIPTION_insert(sk, p, where)                      \

  53.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \

  54.             CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p), (where))

  55. 

  56. #define sk_ACCESS_DESCRIPTION_delete(sk, where) \

  57.   ((ACCESS_DESCRIPTION *)sk_delete(             \

  58.       CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (where)))

  59. 

  60. #define sk_ACCESS_DESCRIPTION_delete_ptr(sk, p)                   \

  61.   ((ACCESS_DESCRIPTION *)sk_delete_ptr(                           \

  62.       CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \

  63.       CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))

  64. 

  65. #define sk_ACCESS_DESCRIPTION_find(sk, out_index, p)                  \

  66.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \

  67.           (out_index), CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))

  68. 

  69. #define sk_ACCESS_DESCRIPTION_shift(sk) \

  70.   ((ACCESS_DESCRIPTION *)sk_shift(      \

  71.       CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))

  72. 

  73. #define sk_ACCESS_DESCRIPTION_push(sk, p)                             \

  74.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \

  75.           CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))

  76. 

  77. #define sk_ACCESS_DESCRIPTION_pop(sk) \

  78.   ((ACCESS_DESCRIPTION *)sk_pop(      \

  79.       CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))

  80. 

  81. #define sk_ACCESS_DESCRIPTION_dup(sk)      \

  82.   ((STACK_OF(ACCESS_DESCRIPTION) *)sk_dup( \

  83.       CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk)))

  84. 

  85. #define sk_ACCESS_DESCRIPTION_sort(sk) \

  86.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))

  87. 

  88. #define sk_ACCESS_DESCRIPTION_is_sorted(sk) \

  89.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk))

  90. 

  91. #define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp)                           \

  92.   ((int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b))       \

  93.        sk_set_cmp_func(                                                        \

  94.            CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk),         \

  95.            CHECKED_CAST(stack_cmp_func, int (*)(const ACCESS_DESCRIPTION **a,  \

  96.                                                 const ACCESS_DESCRIPTION **b), \

  97.                         comp)))

  98. 

  99. #define sk_ACCESS_DESCRIPTION_deep_copy(sk, copy_func, free_func)             \

  100.   ((STACK_OF(ACCESS_DESCRIPTION) *)sk_deep_copy(                              \

  101.       CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), \

  102.       CHECKED_CAST(void *(*)(void *),                                         \

  103.                    ACCESS_DESCRIPTION *(*)(ACCESS_DESCRIPTION *), copy_func), \

  104.       CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *),          \

  105.                    free_func)))

  106. 

  107. /* ASN1_ADB_TABLE */

  108. #define sk_ASN1_ADB_TABLE_new(comp)                 \

  109.   ((STACK_OF(ASN1_ADB_TABLE) *)sk_new(CHECKED_CAST( \

  110.       stack_cmp_func,                               \

  111.       int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b), comp)))

  112. 

  113. #define sk_ASN1_ADB_TABLE_new_null() ((STACK_OF(ASN1_ADB_TABLE) *)sk_new_null())

  114. 

  115. #define sk_ASN1_ADB_TABLE_num(sk) \

  116.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))

  117. 

  118. #define sk_ASN1_ADB_TABLE_zero(sk) \

  119.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk));

  120. 

  121. #define sk_ASN1_ADB_TABLE_value(sk, i) \

  122.   ((ASN1_ADB_TABLE *)sk_value(         \

  123.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk), (i)))

  124. 

  125. #define sk_ASN1_ADB_TABLE_set(sk, i, p)                            \

  126.   ((ASN1_ADB_TABLE *)sk_set(                                       \

  127.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (i), \

  128.       CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))

  129. 

  130. #define sk_ASN1_ADB_TABLE_free(sk) \

  131.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))

  132. 

  133. #define sk_ASN1_ADB_TABLE_pop_free(sk, free_func)             \

  134.   sk_pop_free(                                                \

  135.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \

  136.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func))

  137. 

  138. #define sk_ASN1_ADB_TABLE_insert(sk, p, where)                      \

  139.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \

  140.             CHECKED_CAST(void *, ASN1_ADB_TABLE *, p), (where))

  141. 

  142. #define sk_ASN1_ADB_TABLE_delete(sk, where) \

  143.   ((ASN1_ADB_TABLE *)sk_delete(             \

  144.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (where)))

  145. 

  146. #define sk_ASN1_ADB_TABLE_delete_ptr(sk, p)                   \

  147.   ((ASN1_ADB_TABLE *)sk_delete_ptr(                           \

  148.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \

  149.       CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))

  150. 

  151. #define sk_ASN1_ADB_TABLE_find(sk, out_index, p)                               \

  152.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (out_index), \

  153.           CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))

  154. 

  155. #define sk_ASN1_ADB_TABLE_shift(sk) \

  156.   ((ASN1_ADB_TABLE *)sk_shift(      \

  157.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))

  158. 

  159. #define sk_ASN1_ADB_TABLE_push(sk, p)                             \

  160.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \

  161.           CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))

  162. 

  163. #define sk_ASN1_ADB_TABLE_pop(sk) \

  164.   ((ASN1_ADB_TABLE *)sk_pop(      \

  165.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))

  166. 

  167. #define sk_ASN1_ADB_TABLE_dup(sk)      \

  168.   ((STACK_OF(ASN1_ADB_TABLE) *)sk_dup( \

  169.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk)))

  170. 

  171. #define sk_ASN1_ADB_TABLE_sort(sk) \

  172.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))

  173. 

  174. #define sk_ASN1_ADB_TABLE_is_sorted(sk) \

  175.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))

  176. 

  177. #define sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp)                           \

  178.   ((int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b))           \

  179.        sk_set_cmp_func(                                                    \

  180.            CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk),         \

  181.            CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_ADB_TABLE **a,  \

  182.                                                 const ASN1_ADB_TABLE **b), \

  183.                         comp)))

  184. 

  185. #define sk_ASN1_ADB_TABLE_deep_copy(sk, copy_func, free_func)                \

  186.   ((STACK_OF(ASN1_ADB_TABLE) *)sk_deep_copy(                                 \

  187.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk),    \

  188.       CHECKED_CAST(void *(*)(void *), ASN1_ADB_TABLE *(*)(ASN1_ADB_TABLE *), \

  189.                    copy_func),                                               \

  190.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func)))

  191. 

  192. /* ASN1_GENERALSTRING */

  193. #define sk_ASN1_GENERALSTRING_new(comp)                                    \

  194.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_new(CHECKED_CAST(                    \

  195.       stack_cmp_func,                                                      \

  196.       int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b), \

  197.       comp)))

  198. 

  199. #define sk_ASN1_GENERALSTRING_new_null() \

  200.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())

  201. 

  202. #define sk_ASN1_GENERALSTRING_num(sk) \

  203.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))

  204. 

  205. #define sk_ASN1_GENERALSTRING_zero(sk) \

  206.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk));

  207. 

  208. #define sk_ASN1_GENERALSTRING_value(sk, i) \

  209.   ((ASN1_GENERALSTRING *)sk_value(         \

  210.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), (i)))

  211. 

  212. #define sk_ASN1_GENERALSTRING_set(sk, i, p)                            \

  213.   ((ASN1_GENERALSTRING *)sk_set(                                       \

  214.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (i), \

  215.       CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))

  216. 

  217. #define sk_ASN1_GENERALSTRING_free(sk) \

  218.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))

  219. 

  220. #define sk_ASN1_GENERALSTRING_pop_free(sk, free_func)                        \

  221.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk),    \

  222.               CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *), \

  223.                            free_func))

  224. 

  225. #define sk_ASN1_GENERALSTRING_insert(sk, p, where)                      \

  226.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \

  227.             CHECKED_CAST(void *, ASN1_GENERALSTRING *, p), (where))

  228. 

  229. #define sk_ASN1_GENERALSTRING_delete(sk, where) \

  230.   ((ASN1_GENERALSTRING *)sk_delete(             \

  231.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (where)))

  232. 

  233. #define sk_ASN1_GENERALSTRING_delete_ptr(sk, p)                   \

  234.   ((ASN1_GENERALSTRING *)sk_delete_ptr(                           \

  235.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \

  236.       CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))

  237. 

  238. #define sk_ASN1_GENERALSTRING_find(sk, out_index, p)                  \

  239.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \

  240.           (out_index), CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))

  241. 

  242. #define sk_ASN1_GENERALSTRING_shift(sk) \

  243.   ((ASN1_GENERALSTRING *)sk_shift(      \

  244.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))

  245. 

  246. #define sk_ASN1_GENERALSTRING_push(sk, p)                             \

  247.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \

  248.           CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))

  249. 

  250. #define sk_ASN1_GENERALSTRING_pop(sk) \

  251.   ((ASN1_GENERALSTRING *)sk_pop(      \

  252.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))

  253. 

  254. #define sk_ASN1_GENERALSTRING_dup(sk)      \

  255.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_dup( \

  256.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk)))

  257. 

  258. #define sk_ASN1_GENERALSTRING_sort(sk) \

  259.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))

  260. 

  261. #define sk_ASN1_GENERALSTRING_is_sorted(sk) \

  262.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))

  263. 

  264. #define sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp)                           \

  265.   ((int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b))       \

  266.        sk_set_cmp_func(                                                        \

  267.            CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk),         \

  268.            CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_GENERALSTRING **a,  \

  269.                                                 const ASN1_GENERALSTRING **b), \

  270.                         comp)))

  271. 

  272. #define sk_ASN1_GENERALSTRING_deep_copy(sk, copy_func, free_func)             \

  273.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_deep_copy(                              \

  274.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), \

  275.       CHECKED_CAST(void *(*)(void *),                                         \

  276.                    ASN1_GENERALSTRING *(*)(ASN1_GENERALSTRING *), copy_func), \

  277.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *),          \

  278.                    free_func)))

  279. 

  280. /* ASN1_INTEGER */

  281. #define sk_ASN1_INTEGER_new(comp)                                              \

  282.   ((STACK_OF(ASN1_INTEGER) *)sk_new(CHECKED_CAST(                              \

  283.       stack_cmp_func, int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \

  284.       comp)))

  285. 

  286. #define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)sk_new_null())

  287. 

  288. #define sk_ASN1_INTEGER_num(sk) \

  289.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))

  290. 

  291. #define sk_ASN1_INTEGER_zero(sk) \

  292.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk));

  293. 

  294. #define sk_ASN1_INTEGER_value(sk, i) \

  295.   ((ASN1_INTEGER *)sk_value(         \

  296.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk), (i)))

  297. 

  298. #define sk_ASN1_INTEGER_set(sk, i, p)                            \

  299.   ((ASN1_INTEGER *)sk_set(                                       \

  300.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (i), \

  301.       CHECKED_CAST(void *, ASN1_INTEGER *, p)))

  302. 

  303. #define sk_ASN1_INTEGER_free(sk) \

  304.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))

  305. 

  306. #define sk_ASN1_INTEGER_pop_free(sk, free_func)             \

  307.   sk_pop_free(                                              \

  308.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \

  309.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func))

  310. 

  311. #define sk_ASN1_INTEGER_insert(sk, p, where)                      \

  312.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \

  313.             CHECKED_CAST(void *, ASN1_INTEGER *, p), (where))

  314. 

  315. #define sk_ASN1_INTEGER_delete(sk, where) \

  316.   ((ASN1_INTEGER *)sk_delete(             \

  317.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (where)))

  318. 

  319. #define sk_ASN1_INTEGER_delete_ptr(sk, p)                   \

  320.   ((ASN1_INTEGER *)sk_delete_ptr(                           \

  321.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \

  322.       CHECKED_CAST(void *, ASN1_INTEGER *, p)))

  323. 

  324. #define sk_ASN1_INTEGER_find(sk, out_index, p)                               \

  325.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (out_index), \

  326.           CHECKED_CAST(void *, ASN1_INTEGER *, p))

  327. 

  328. #define sk_ASN1_INTEGER_shift(sk) \

  329.   ((ASN1_INTEGER *)sk_shift(      \

  330.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))

  331. 

  332. #define sk_ASN1_INTEGER_push(sk, p)                             \

  333.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \

  334.           CHECKED_CAST(void *, ASN1_INTEGER *, p))

  335. 

  336. #define sk_ASN1_INTEGER_pop(sk) \

  337.   ((ASN1_INTEGER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))

  338. 

  339. #define sk_ASN1_INTEGER_dup(sk)      \

  340.   ((STACK_OF(ASN1_INTEGER) *)sk_dup( \

  341.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk)))

  342. 

  343. #define sk_ASN1_INTEGER_sort(sk) \

  344.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))

  345. 

  346. #define sk_ASN1_INTEGER_is_sorted(sk) \

  347.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_INTEGER) *, sk))

  348. 

  349. #define sk_ASN1_INTEGER_set_cmp_func(sk, comp)                               \

  350.   ((int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b))sk_set_cmp_func( \

  351.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk),                  \

  352.       CHECKED_CAST(stack_cmp_func,                                           \

  353.                    int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b),  \

  354.                    comp)))

  355. 

  356. #define sk_ASN1_INTEGER_deep_copy(sk, copy_func, free_func)              \

  357.   ((STACK_OF(ASN1_INTEGER) *)sk_deep_copy(                               \

  358.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk),  \

  359.       CHECKED_CAST(void *(*)(void *), ASN1_INTEGER *(*)(ASN1_INTEGER *), \

  360.                    copy_func),                                           \

  361.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func)))

  362. 

  363. /* ASN1_OBJECT */

  364. #define sk_ASN1_OBJECT_new(comp)                                             \

  365.   ((STACK_OF(ASN1_OBJECT) *)sk_new(CHECKED_CAST(                             \

  366.       stack_cmp_func, int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \

  367.       comp)))

  368. 

  369. #define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)sk_new_null())

  370. 

  371. #define sk_ASN1_OBJECT_num(sk) \

  372.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))

  373. 

  374. #define sk_ASN1_OBJECT_zero(sk) \

  375.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk));

  376. 

  377. #define sk_ASN1_OBJECT_value(sk, i) \

  378.   ((ASN1_OBJECT *)sk_value(         \

  379.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk), (i)))

  380. 

  381. #define sk_ASN1_OBJECT_set(sk, i, p)                                          \

  382.   ((ASN1_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \

  383.                          (i), CHECKED_CAST(void *, ASN1_OBJECT *, p)))

  384. 

  385. #define sk_ASN1_OBJECT_free(sk) \

  386.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))

  387. 

  388. #define sk_ASN1_OBJECT_pop_free(sk, free_func)             \

  389.   sk_pop_free(                                             \

  390.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \

  391.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func))

  392. 

  393. #define sk_ASN1_OBJECT_insert(sk, p, where)                      \

  394.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \

  395.             CHECKED_CAST(void *, ASN1_OBJECT *, p), (where))

  396. 

  397. #define sk_ASN1_OBJECT_delete(sk, where) \

  398.   ((ASN1_OBJECT *)sk_delete(             \

  399.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (where)))

  400. 

  401. #define sk_ASN1_OBJECT_delete_ptr(sk, p)                   \

  402.   ((ASN1_OBJECT *)sk_delete_ptr(                           \

  403.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \

  404.       CHECKED_CAST(void *, ASN1_OBJECT *, p)))

  405. 

  406. #define sk_ASN1_OBJECT_find(sk, out_index, p)                               \

  407.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (out_index), \

  408.           CHECKED_CAST(void *, ASN1_OBJECT *, p))

  409. 

  410. #define sk_ASN1_OBJECT_shift(sk) \

  411.   ((ASN1_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))

  412. 

  413. #define sk_ASN1_OBJECT_push(sk, p)                             \

  414.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \

  415.           CHECKED_CAST(void *, ASN1_OBJECT *, p))

  416. 

  417. #define sk_ASN1_OBJECT_pop(sk) \

  418.   ((ASN1_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))

  419. 

  420. #define sk_ASN1_OBJECT_dup(sk)      \

  421.   ((STACK_OF(ASN1_OBJECT) *)sk_dup( \

  422.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk)))

  423. 

  424. #define sk_ASN1_OBJECT_sort(sk) \

  425.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))

  426. 

  427. #define sk_ASN1_OBJECT_is_sorted(sk) \

  428.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_OBJECT) *, sk))

  429. 

  430. #define sk_ASN1_OBJECT_set_cmp_func(sk, comp)                              \

  431.   ((int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b))sk_set_cmp_func( \

  432.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk),                 \

  433.       CHECKED_CAST(stack_cmp_func,                                         \

  434.                    int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b),  \

  435.                    comp)))

  436. 

  437. #define sk_ASN1_OBJECT_deep_copy(sk, copy_func, free_func)             \

  438.   ((STACK_OF(ASN1_OBJECT) *)sk_deep_copy(                              \

  439.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk), \

  440.       CHECKED_CAST(void *(*)(void *), ASN1_OBJECT *(*)(ASN1_OBJECT *), \

  441.                    copy_func),                                         \

  442.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func)))

  443. 

  444. /* ASN1_STRING_TABLE */

  445. #define sk_ASN1_STRING_TABLE_new(comp)                                   \

  446.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_new(CHECKED_CAST(                   \

  447.       stack_cmp_func,                                                    \

  448.       int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b), \

  449.       comp)))

  450. 

  451. #define sk_ASN1_STRING_TABLE_new_null() \

  452.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())

  453. 

  454. #define sk_ASN1_STRING_TABLE_num(sk) \

  455.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))

  456. 

  457. #define sk_ASN1_STRING_TABLE_zero(sk) \

  458.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk));

  459. 

  460. #define sk_ASN1_STRING_TABLE_value(sk, i) \

  461.   ((ASN1_STRING_TABLE *)sk_value(         \

  462.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), (i)))

  463. 

  464. #define sk_ASN1_STRING_TABLE_set(sk, i, p)                            \

  465.   ((ASN1_STRING_TABLE *)sk_set(                                       \

  466.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (i), \

  467.       CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))

  468. 

  469. #define sk_ASN1_STRING_TABLE_free(sk) \

  470.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))

  471. 

  472. #define sk_ASN1_STRING_TABLE_pop_free(sk, free_func)                        \

  473.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk),    \

  474.               CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *), \

  475.                            free_func))

  476. 

  477. #define sk_ASN1_STRING_TABLE_insert(sk, p, where)                      \

  478.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \

  479.             CHECKED_CAST(void *, ASN1_STRING_TABLE *, p), (where))

  480. 

  481. #define sk_ASN1_STRING_TABLE_delete(sk, where) \

  482.   ((ASN1_STRING_TABLE *)sk_delete(             \

  483.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (where)))

  484. 

  485. #define sk_ASN1_STRING_TABLE_delete_ptr(sk, p)                   \

  486.   ((ASN1_STRING_TABLE *)sk_delete_ptr(                           \

  487.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \

  488.       CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))

  489. 

  490. #define sk_ASN1_STRING_TABLE_find(sk, out_index, p)                  \

  491.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \

  492.           (out_index), CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))

  493. 

  494. #define sk_ASN1_STRING_TABLE_shift(sk) \

  495.   ((ASN1_STRING_TABLE *)sk_shift(      \

  496.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))

  497. 

  498. #define sk_ASN1_STRING_TABLE_push(sk, p)                             \

  499.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \

  500.           CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))

  501. 

  502. #define sk_ASN1_STRING_TABLE_pop(sk) \

  503.   ((ASN1_STRING_TABLE *)sk_pop(      \

  504.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))

  505. 

  506. #define sk_ASN1_STRING_TABLE_dup(sk)      \

  507.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_dup( \

  508.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk)))

  509. 

  510. #define sk_ASN1_STRING_TABLE_sort(sk) \

  511.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))

  512. 

  513. #define sk_ASN1_STRING_TABLE_is_sorted(sk) \

  514.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))

  515. 

  516. #define sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp)                           \

  517.   ((int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b))        \

  518.        sk_set_cmp_func(                                                       \

  519.            CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk),         \

  520.            CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_STRING_TABLE **a,  \

  521.                                                 const ASN1_STRING_TABLE **b), \

  522.                         comp)))

  523. 

  524. #define sk_ASN1_STRING_TABLE_deep_copy(sk, copy_func, free_func)             \

  525.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_deep_copy(                              \

  526.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), \

  527.       CHECKED_CAST(void *(*)(void *),                                        \

  528.                    ASN1_STRING_TABLE *(*)(ASN1_STRING_TABLE *), copy_func),  \

  529.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *),          \

  530.                    free_func)))

  531. 

  532. /* ASN1_TYPE */

  533. #define sk_ASN1_TYPE_new(comp)     \

  534.   ((STACK_OF(ASN1_TYPE) *)sk_new(  \

  535.       CHECKED_CAST(stack_cmp_func, \

  536.                    int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))

  537. 

  538. #define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)sk_new_null())

  539. 

  540. #define sk_ASN1_TYPE_num(sk) \

  541.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))

  542. 

  543. #define sk_ASN1_TYPE_zero(sk) \

  544.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk));

  545. 

  546. #define sk_ASN1_TYPE_value(sk, i) \

  547.   ((ASN1_TYPE *)sk_value(         \

  548.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk), (i)))

  549. 

  550. #define sk_ASN1_TYPE_set(sk, i, p)                                             \

  551.   ((ASN1_TYPE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (i), \

  552.                        CHECKED_CAST(void *, ASN1_TYPE *, p)))

  553. 

  554. #define sk_ASN1_TYPE_free(sk) \

  555.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))

  556. 

  557. #define sk_ASN1_TYPE_pop_free(sk, free_func)             \

  558.   sk_pop_free(                                           \

  559.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \

  560.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func))

  561. 

  562. #define sk_ASN1_TYPE_insert(sk, p, where)                      \

  563.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \

  564.             CHECKED_CAST(void *, ASN1_TYPE *, p), (where))

  565. 

  566. #define sk_ASN1_TYPE_delete(sk, where)                                       \

  567.   ((ASN1_TYPE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \

  568.                           (where)))

  569. 

  570. #define sk_ASN1_TYPE_delete_ptr(sk, p)                   \

  571.   ((ASN1_TYPE *)sk_delete_ptr(                           \

  572.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \

  573.       CHECKED_CAST(void *, ASN1_TYPE *, p)))

  574. 

  575. #define sk_ASN1_TYPE_find(sk, out_index, p)                               \

  576.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (out_index), \

  577.           CHECKED_CAST(void *, ASN1_TYPE *, p))

  578. 

  579. #define sk_ASN1_TYPE_shift(sk) \

  580.   ((ASN1_TYPE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))

  581. 

  582. #define sk_ASN1_TYPE_push(sk, p)                             \

  583.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \

  584.           CHECKED_CAST(void *, ASN1_TYPE *, p))

  585. 

  586. #define sk_ASN1_TYPE_pop(sk) \

  587.   ((ASN1_TYPE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))

  588. 

  589. #define sk_ASN1_TYPE_dup(sk)      \

  590.   ((STACK_OF(ASN1_TYPE) *)sk_dup( \

  591.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk)))

  592. 

  593. #define sk_ASN1_TYPE_sort(sk) \

  594.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))

  595. 

  596. #define sk_ASN1_TYPE_is_sorted(sk) \

  597.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_TYPE) *, sk))

  598. 

  599. #define sk_ASN1_TYPE_set_cmp_func(sk, comp)                            \

  600.   ((int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b))sk_set_cmp_func( \

  601.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk),               \

  602.       CHECKED_CAST(stack_cmp_func,                                     \

  603.                    int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))

  604. 

  605. #define sk_ASN1_TYPE_deep_copy(sk, copy_func, free_func)                       \

  606.   ((STACK_OF(ASN1_TYPE) *)sk_deep_copy(                                        \

  607.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk),           \

  608.       CHECKED_CAST(void *(*)(void *), ASN1_TYPE *(*)(ASN1_TYPE *), copy_func), \

  609.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func)))

  610. 

  611. /* ASN1_VALUE */

  612. #define sk_ASN1_VALUE_new(comp)                                            \

  613.   ((STACK_OF(ASN1_VALUE) *)sk_new(CHECKED_CAST(                            \

  614.       stack_cmp_func, int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \

  615.       comp)))

  616. 

  617. #define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)sk_new_null())

  618. 

  619. #define sk_ASN1_VALUE_num(sk) \

  620.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))

  621. 

  622. #define sk_ASN1_VALUE_zero(sk) \

  623.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk));

  624. 

  625. #define sk_ASN1_VALUE_value(sk, i) \

  626.   ((ASN1_VALUE *)sk_value(         \

  627.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk), (i)))

  628. 

  629. #define sk_ASN1_VALUE_set(sk, i, p)                                         \

  630.   ((ASN1_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  631.                         (i), CHECKED_CAST(void *, ASN1_VALUE *, p)))

  632. 

  633. #define sk_ASN1_VALUE_free(sk) \

  634.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))

  635. 

  636. #define sk_ASN1_VALUE_pop_free(sk, free_func)             \

  637.   sk_pop_free(                                            \

  638.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  639.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func))

  640. 

  641. #define sk_ASN1_VALUE_insert(sk, p, where)                      \

  642.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  643.             CHECKED_CAST(void *, ASN1_VALUE *, p), (where))

  644. 

  645. #define sk_ASN1_VALUE_delete(sk, where)                                        \

  646.   ((ASN1_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  647.                            (where)))

  648. 

  649. #define sk_ASN1_VALUE_delete_ptr(sk, p)                   \

  650.   ((ASN1_VALUE *)sk_delete_ptr(                           \

  651.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  652.       CHECKED_CAST(void *, ASN1_VALUE *, p)))

  653. 

  654. #define sk_ASN1_VALUE_find(sk, out_index, p)                               \

  655.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), (out_index), \

  656.           CHECKED_CAST(void *, ASN1_VALUE *, p))

  657. 

  658. #define sk_ASN1_VALUE_shift(sk) \

  659.   ((ASN1_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))

  660. 

  661. #define sk_ASN1_VALUE_push(sk, p)                             \

  662.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \

  663.           CHECKED_CAST(void *, ASN1_VALUE *, p))

  664. 

  665. #define sk_ASN1_VALUE_pop(sk) \

  666.   ((ASN1_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))

  667. 

  668. #define sk_ASN1_VALUE_dup(sk)      \

  669.   ((STACK_OF(ASN1_VALUE) *)sk_dup( \

  670.       CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk)))

  671. 

  672. #define sk_ASN1_VALUE_sort(sk) \

  673.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))

  674. 

  675. #define sk_ASN1_VALUE_is_sorted(sk) \

  676.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(ASN1_VALUE) *, sk))

  677. 

  678. #define sk_ASN1_VALUE_set_cmp_func(sk, comp)                             \

  679.   ((int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b))sk_set_cmp_func( \

  680.       CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk),                \

  681.       CHECKED_CAST(stack_cmp_func,                                       \

  682.                    int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b),  \

  683.                    comp)))

  684. 

  685. #define sk_ASN1_VALUE_deep_copy(sk, copy_func, free_func)             \

  686.   ((STACK_OF(ASN1_VALUE) *)sk_deep_copy(                              \

  687.       CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk), \

  688.       CHECKED_CAST(void *(*)(void *), ASN1_VALUE *(*)(ASN1_VALUE *),  \

  689.                    copy_func),                                        \

  690.       CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func)))

  691. 

  692. /* BIO */

  693. #define sk_BIO_new(comp)                 \

  694.   ((STACK_OF(BIO) *)sk_new(CHECKED_CAST( \

  695.       stack_cmp_func, int (*)(const BIO **a, const BIO **b), comp)))

  696. 

  697. #define sk_BIO_new_null() ((STACK_OF(BIO) *)sk_new_null())

  698. 

  699. #define sk_BIO_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))

  700. 

  701. #define sk_BIO_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk));

  702. 

  703. #define sk_BIO_value(sk, i) \

  704.   ((BIO *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk), (i)))

  705. 

  706. #define sk_BIO_set(sk, i, p)                                       \

  707.   ((BIO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (i), \

  708.                  CHECKED_CAST(void *, BIO *, p)))

  709. 

  710. #define sk_BIO_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))

  711. 

  712. #define sk_BIO_pop_free(sk, free_func)                     \

  713.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \

  714.               CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func))

  715. 

  716. #define sk_BIO_insert(sk, p, where)                      \

  717.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \

  718.             CHECKED_CAST(void *, BIO *, p), (where))

  719. 

  720. #define sk_BIO_delete(sk, where) \

  721.   ((BIO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (where)))

  722. 

  723. #define sk_BIO_delete_ptr(sk, p)                                     \

  724.   ((BIO *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \

  725.                         CHECKED_CAST(void *, BIO *, p)))

  726. 

  727. #define sk_BIO_find(sk, out_index, p)                               \

  728.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (out_index), \

  729.           CHECKED_CAST(void *, BIO *, p))

  730. 

  731. #define sk_BIO_shift(sk) \

  732.   ((BIO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))

  733. 

  734. #define sk_BIO_push(sk, p)                             \

  735.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \

  736.           CHECKED_CAST(void *, BIO *, p))

  737. 

  738. #define sk_BIO_pop(sk) \

  739.   ((BIO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))

  740. 

  741. #define sk_BIO_dup(sk) \

  742.   ((STACK_OF(BIO) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk)))

  743. 

  744. #define sk_BIO_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))

  745. 

  746. #define sk_BIO_is_sorted(sk) \

  747.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BIO) *, sk))

  748. 

  749. #define sk_BIO_set_cmp_func(sk, comp)                                     \

  750.   ((int (*)(const BIO **a, const BIO **b))sk_set_cmp_func(                \

  751.       CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk),                        \

  752.       CHECKED_CAST(stack_cmp_func, int (*)(const BIO **a, const BIO **b), \

  753.                    comp)))

  754. 

  755. #define sk_BIO_deep_copy(sk, copy_func, free_func)                 \

  756.   ((STACK_OF(BIO) *)sk_deep_copy(                                  \

  757.       CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk),     \

  758.       CHECKED_CAST(void *(*)(void *), BIO *(*)(BIO *), copy_func), \

  759.       CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func)))

  760. 

  761. /* BY_DIR_ENTRY */

  762. #define sk_BY_DIR_ENTRY_new(comp)                                              \

  763.   ((STACK_OF(BY_DIR_ENTRY) *)sk_new(CHECKED_CAST(                              \

  764.       stack_cmp_func, int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \

  765.       comp)))

  766. 

  767. #define sk_BY_DIR_ENTRY_new_null() ((STACK_OF(BY_DIR_ENTRY) *)sk_new_null())

  768. 

  769. #define sk_BY_DIR_ENTRY_num(sk) \

  770.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))

  771. 

  772. #define sk_BY_DIR_ENTRY_zero(sk) \

  773.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk));

  774. 

  775. #define sk_BY_DIR_ENTRY_value(sk, i) \

  776.   ((BY_DIR_ENTRY *)sk_value(         \

  777.       CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk), (i)))

  778. 

  779. #define sk_BY_DIR_ENTRY_set(sk, i, p)                            \

  780.   ((BY_DIR_ENTRY *)sk_set(                                       \

  781.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (i), \

  782.       CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))

  783. 

  784. #define sk_BY_DIR_ENTRY_free(sk) \

  785.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))

  786. 

  787. #define sk_BY_DIR_ENTRY_pop_free(sk, free_func)             \

  788.   sk_pop_free(                                              \

  789.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \

  790.       CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func))

  791. 

  792. #define sk_BY_DIR_ENTRY_insert(sk, p, where)                      \

  793.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \

  794.             CHECKED_CAST(void *, BY_DIR_ENTRY *, p), (where))

  795. 

  796. #define sk_BY_DIR_ENTRY_delete(sk, where) \

  797.   ((BY_DIR_ENTRY *)sk_delete(             \

  798.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (where)))

  799. 

  800. #define sk_BY_DIR_ENTRY_delete_ptr(sk, p)                   \

  801.   ((BY_DIR_ENTRY *)sk_delete_ptr(                           \

  802.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \

  803.       CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))

  804. 

  805. #define sk_BY_DIR_ENTRY_find(sk, out_index, p)                               \

  806.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (out_index), \

  807.           CHECKED_CAST(void *, BY_DIR_ENTRY *, p))

  808. 

  809. #define sk_BY_DIR_ENTRY_shift(sk) \

  810.   ((BY_DIR_ENTRY *)sk_shift(      \

  811.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))

  812. 

  813. #define sk_BY_DIR_ENTRY_push(sk, p)                             \

  814.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \

  815.           CHECKED_CAST(void *, BY_DIR_ENTRY *, p))

  816. 

  817. #define sk_BY_DIR_ENTRY_pop(sk) \

  818.   ((BY_DIR_ENTRY *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))

  819. 

  820. #define sk_BY_DIR_ENTRY_dup(sk)      \

  821.   ((STACK_OF(BY_DIR_ENTRY) *)sk_dup( \

  822.       CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk)))

  823. 

  824. #define sk_BY_DIR_ENTRY_sort(sk) \

  825.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))

  826. 

  827. #define sk_BY_DIR_ENTRY_is_sorted(sk) \

  828.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))

  829. 

  830. #define sk_BY_DIR_ENTRY_set_cmp_func(sk, comp)                               \

  831.   ((int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b))sk_set_cmp_func( \

  832.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk),                  \

  833.       CHECKED_CAST(stack_cmp_func,                                           \

  834.                    int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b),  \

  835.                    comp)))

  836. 

  837. #define sk_BY_DIR_ENTRY_deep_copy(sk, copy_func, free_func)              \

  838.   ((STACK_OF(BY_DIR_ENTRY) *)sk_deep_copy(                               \

  839.       CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk),  \

  840.       CHECKED_CAST(void *(*)(void *), BY_DIR_ENTRY *(*)(BY_DIR_ENTRY *), \

  841.                    copy_func),                                           \

  842.       CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func)))

  843. 

  844. /* BY_DIR_HASH */

  845. #define sk_BY_DIR_HASH_new(comp)                                             \

  846.   ((STACK_OF(BY_DIR_HASH) *)sk_new(CHECKED_CAST(                             \

  847.       stack_cmp_func, int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \

  848.       comp)))

  849. 

  850. #define sk_BY_DIR_HASH_new_null() ((STACK_OF(BY_DIR_HASH) *)sk_new_null())

  851. 

  852. #define sk_BY_DIR_HASH_num(sk) \

  853.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))

  854. 

  855. #define sk_BY_DIR_HASH_zero(sk) \

  856.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk));

  857. 

  858. #define sk_BY_DIR_HASH_value(sk, i) \

  859.   ((BY_DIR_HASH *)sk_value(         \

  860.       CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk), (i)))

  861. 

  862. #define sk_BY_DIR_HASH_set(sk, i, p)                                          \

  863.   ((BY_DIR_HASH *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \

  864.                          (i), CHECKED_CAST(void *, BY_DIR_HASH *, p)))

  865. 

  866. #define sk_BY_DIR_HASH_free(sk) \

  867.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))

  868. 

  869. #define sk_BY_DIR_HASH_pop_free(sk, free_func)             \

  870.   sk_pop_free(                                             \

  871.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \

  872.       CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func))

  873. 

  874. #define sk_BY_DIR_HASH_insert(sk, p, where)                      \

  875.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \

  876.             CHECKED_CAST(void *, BY_DIR_HASH *, p), (where))

  877. 

  878. #define sk_BY_DIR_HASH_delete(sk, where) \

  879.   ((BY_DIR_HASH *)sk_delete(             \

  880.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (where)))

  881. 

  882. #define sk_BY_DIR_HASH_delete_ptr(sk, p)                   \

  883.   ((BY_DIR_HASH *)sk_delete_ptr(                           \

  884.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \

  885.       CHECKED_CAST(void *, BY_DIR_HASH *, p)))

  886. 

  887. #define sk_BY_DIR_HASH_find(sk, out_index, p)                               \

  888.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (out_index), \

  889.           CHECKED_CAST(void *, BY_DIR_HASH *, p))

  890. 

  891. #define sk_BY_DIR_HASH_shift(sk) \

  892.   ((BY_DIR_HASH *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))

  893. 

  894. #define sk_BY_DIR_HASH_push(sk, p)                             \

  895.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \

  896.           CHECKED_CAST(void *, BY_DIR_HASH *, p))

  897. 

  898. #define sk_BY_DIR_HASH_pop(sk) \

  899.   ((BY_DIR_HASH *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))

  900. 

  901. #define sk_BY_DIR_HASH_dup(sk)      \

  902.   ((STACK_OF(BY_DIR_HASH) *)sk_dup( \

  903.       CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk)))

  904. 

  905. #define sk_BY_DIR_HASH_sort(sk) \

  906.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))

  907. 

  908. #define sk_BY_DIR_HASH_is_sorted(sk) \

  909.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(BY_DIR_HASH) *, sk))

  910. 

  911. #define sk_BY_DIR_HASH_set_cmp_func(sk, comp)                              \

  912.   ((int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b))sk_set_cmp_func( \

  913.       CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk),                 \

  914.       CHECKED_CAST(stack_cmp_func,                                         \

  915.                    int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b),  \

  916.                    comp)))

  917. 

  918. #define sk_BY_DIR_HASH_deep_copy(sk, copy_func, free_func)             \

  919.   ((STACK_OF(BY_DIR_HASH) *)sk_deep_copy(                              \

  920.       CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk), \

  921.       CHECKED_CAST(void *(*)(void *), BY_DIR_HASH *(*)(BY_DIR_HASH *), \

  922.                    copy_func),                                         \

  923.       CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func)))

  924. 

  925. /* CONF_VALUE */

  926. #define sk_CONF_VALUE_new(comp)                                            \

  927.   ((STACK_OF(CONF_VALUE) *)sk_new(CHECKED_CAST(                            \

  928.       stack_cmp_func, int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \

  929.       comp)))

  930. 

  931. #define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)sk_new_null())

  932. 

  933. #define sk_CONF_VALUE_num(sk) \

  934.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))

  935. 

  936. #define sk_CONF_VALUE_zero(sk) \

  937.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk));

  938. 

  939. #define sk_CONF_VALUE_value(sk, i) \

  940.   ((CONF_VALUE *)sk_value(         \

  941.       CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk), (i)))

  942. 

  943. #define sk_CONF_VALUE_set(sk, i, p)                                         \

  944.   ((CONF_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  945.                         (i), CHECKED_CAST(void *, CONF_VALUE *, p)))

  946. 

  947. #define sk_CONF_VALUE_free(sk) \

  948.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))

  949. 

  950. #define sk_CONF_VALUE_pop_free(sk, free_func)             \

  951.   sk_pop_free(                                            \

  952.       CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  953.       CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func))

  954. 

  955. #define sk_CONF_VALUE_insert(sk, p, where)                      \

  956.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  957.             CHECKED_CAST(void *, CONF_VALUE *, p), (where))

  958. 

  959. #define sk_CONF_VALUE_delete(sk, where)                                        \

  960.   ((CONF_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  961.                            (where)))

  962. 

  963. #define sk_CONF_VALUE_delete_ptr(sk, p)                   \

  964.   ((CONF_VALUE *)sk_delete_ptr(                           \

  965.       CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  966.       CHECKED_CAST(void *, CONF_VALUE *, p)))

  967. 

  968. #define sk_CONF_VALUE_find(sk, out_index, p)                               \

  969.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), (out_index), \

  970.           CHECKED_CAST(void *, CONF_VALUE *, p))

  971. 

  972. #define sk_CONF_VALUE_shift(sk) \

  973.   ((CONF_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))

  974. 

  975. #define sk_CONF_VALUE_push(sk, p)                             \

  976.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \

  977.           CHECKED_CAST(void *, CONF_VALUE *, p))

  978. 

  979. #define sk_CONF_VALUE_pop(sk) \

  980.   ((CONF_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))

  981. 

  982. #define sk_CONF_VALUE_dup(sk)      \

  983.   ((STACK_OF(CONF_VALUE) *)sk_dup( \

  984.       CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk)))

  985. 

  986. #define sk_CONF_VALUE_sort(sk) \

  987.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))

  988. 

  989. #define sk_CONF_VALUE_is_sorted(sk) \

  990.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(CONF_VALUE) *, sk))

  991. 

  992. #define sk_CONF_VALUE_set_cmp_func(sk, comp)                             \

  993.   ((int (*)(const CONF_VALUE **a, const CONF_VALUE **b))sk_set_cmp_func( \

  994.       CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk),                \

  995.       CHECKED_CAST(stack_cmp_func,                                       \

  996.                    int (*)(const CONF_VALUE **a, const CONF_VALUE **b),  \

  997.                    comp)))

  998. 

  999. #define sk_CONF_VALUE_deep_copy(sk, copy_func, free_func)             \

  1000.   ((STACK_OF(CONF_VALUE) *)sk_deep_copy(                              \

  1001.       CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk), \

  1002.       CHECKED_CAST(void *(*)(void *), CONF_VALUE *(*)(CONF_VALUE *),  \

  1003.                    copy_func),                                        \

  1004.       CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func)))

  1005. 

  1006. /* CRYPTO_EX_DATA_FUNCS */

  1007. #define sk_CRYPTO_EX_DATA_FUNCS_new(comp)                                      \

  1008.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new(CHECKED_CAST(                      \

  1009.       stack_cmp_func,                                                          \

  1010.       int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b), \

  1011.       comp)))

  1012. 

  1013. #define sk_CRYPTO_EX_DATA_FUNCS_new_null() \

  1014.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())

  1015. 

  1016. #define sk_CRYPTO_EX_DATA_FUNCS_num(sk) \

  1017.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

  1018. 

  1019. #define sk_CRYPTO_EX_DATA_FUNCS_zero(sk) \

  1020.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk));

  1021. 

  1022. #define sk_CRYPTO_EX_DATA_FUNCS_value(sk, i)                              \

  1023.   ((CRYPTO_EX_DATA_FUNCS *)sk_value(                                      \

  1024.       CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \

  1025.       (i)))

  1026. 

  1027. #define sk_CRYPTO_EX_DATA_FUNCS_set(sk, i, p)                            \

  1028.   ((CRYPTO_EX_DATA_FUNCS *)sk_set(                                       \

  1029.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (i), \

  1030.       CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))

  1031. 

  1032. #define sk_CRYPTO_EX_DATA_FUNCS_free(sk) \

  1033.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

  1034. 

  1035. #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func)                        \

  1036.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk),    \

  1037.               CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *), \

  1038.                            free_func))

  1039. 

  1040. #define sk_CRYPTO_EX_DATA_FUNCS_insert(sk, p, where)                      \

  1041.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \

  1042.             CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p), (where))

  1043. 

  1044. #define sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where) \

  1045.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete(             \

  1046.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (where)))

  1047. 

  1048. #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p)                   \

  1049.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr(                           \

  1050.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \

  1051.       CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))

  1052. 

  1053. #define sk_CRYPTO_EX_DATA_FUNCS_find(sk, out_index, p)                  \

  1054.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \

  1055.           (out_index), CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))

  1056. 

  1057. #define sk_CRYPTO_EX_DATA_FUNCS_shift(sk) \

  1058.   ((CRYPTO_EX_DATA_FUNCS *)sk_shift(      \

  1059.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

  1060. 

  1061. #define sk_CRYPTO_EX_DATA_FUNCS_push(sk, p)                             \

  1062.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \

  1063.           CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))

  1064. 

  1065. #define sk_CRYPTO_EX_DATA_FUNCS_pop(sk) \

  1066.   ((CRYPTO_EX_DATA_FUNCS *)sk_pop(      \

  1067.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

  1068. 

  1069. #define sk_CRYPTO_EX_DATA_FUNCS_dup(sk)      \

  1070.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_dup( \

  1071.       CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

  1072. 

  1073. #define sk_CRYPTO_EX_DATA_FUNCS_sort(sk) \

  1074.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

  1075. 

  1076. #define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk) \

  1077.   sk_is_sorted(                               \

  1078.       CHECKED_CAST(_STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

  1079. 

  1080. #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp)                       \

  1081.   ((int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b)) \

  1082.        sk_set_cmp_func(                                                      \

  1083.            CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk),     \

  1084.            CHECKED_CAST(stack_cmp_func,                                      \

  1085.                         int (*)(const CRYPTO_EX_DATA_FUNCS **a,              \

  1086.                                 const CRYPTO_EX_DATA_FUNCS **b),             \

  1087.                         comp)))

  1088. 

  1089. #define sk_CRYPTO_EX_DATA_FUNCS_deep_copy(sk, copy_func, free_func)        \

  1090.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_deep_copy(                         \

  1091.       CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \

  1092.                    sk),                                                    \

  1093.       CHECKED_CAST(void *(*)(void *),                                      \

  1094.                    CRYPTO_EX_DATA_FUNCS *(*)(CRYPTO_EX_DATA_FUNCS *),      \

  1095.                    copy_func),                                             \

  1096.       CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *),     \

  1097.                    free_func)))

  1098. 

  1099. /* DIST_POINT */

  1100. #define sk_DIST_POINT_new(comp)                                            \

  1101.   ((STACK_OF(DIST_POINT) *)sk_new(CHECKED_CAST(                            \

  1102.       stack_cmp_func, int (*)(const DIST_POINT **a, const DIST_POINT **b), \

  1103.       comp)))

  1104. 

  1105. #define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)sk_new_null())

  1106. 

  1107. #define sk_DIST_POINT_num(sk) \

  1108.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))

  1109. 

  1110. #define sk_DIST_POINT_zero(sk) \

  1111.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk));

  1112. 

  1113. #define sk_DIST_POINT_value(sk, i) \

  1114.   ((DIST_POINT *)sk_value(         \

  1115.       CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk), (i)))

  1116. 

  1117. #define sk_DIST_POINT_set(sk, i, p)                                         \

  1118.   ((DIST_POINT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1119.                         (i), CHECKED_CAST(void *, DIST_POINT *, p)))

  1120. 

  1121. #define sk_DIST_POINT_free(sk) \

  1122.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))

  1123. 

  1124. #define sk_DIST_POINT_pop_free(sk, free_func)             \

  1125.   sk_pop_free(                                            \

  1126.       CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1127.       CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func))

  1128. 

  1129. #define sk_DIST_POINT_insert(sk, p, where)                      \

  1130.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1131.             CHECKED_CAST(void *, DIST_POINT *, p), (where))

  1132. 

  1133. #define sk_DIST_POINT_delete(sk, where)                                        \

  1134.   ((DIST_POINT *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1135.                            (where)))

  1136. 

  1137. #define sk_DIST_POINT_delete_ptr(sk, p)                   \

  1138.   ((DIST_POINT *)sk_delete_ptr(                           \

  1139.       CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1140.       CHECKED_CAST(void *, DIST_POINT *, p)))

  1141. 

  1142. #define sk_DIST_POINT_find(sk, out_index, p)                               \

  1143.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), (out_index), \

  1144.           CHECKED_CAST(void *, DIST_POINT *, p))

  1145. 

  1146. #define sk_DIST_POINT_shift(sk) \

  1147.   ((DIST_POINT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))

  1148. 

  1149. #define sk_DIST_POINT_push(sk, p)                             \

  1150.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \

  1151.           CHECKED_CAST(void *, DIST_POINT *, p))

  1152. 

  1153. #define sk_DIST_POINT_pop(sk) \

  1154.   ((DIST_POINT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))

  1155. 

  1156. #define sk_DIST_POINT_dup(sk)      \

  1157.   ((STACK_OF(DIST_POINT) *)sk_dup( \

  1158.       CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk)))

  1159. 

  1160. #define sk_DIST_POINT_sort(sk) \

  1161.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))

  1162. 

  1163. #define sk_DIST_POINT_is_sorted(sk) \

  1164.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(DIST_POINT) *, sk))

  1165. 

  1166. #define sk_DIST_POINT_set_cmp_func(sk, comp)                             \

  1167.   ((int (*)(const DIST_POINT **a, const DIST_POINT **b))sk_set_cmp_func( \

  1168.       CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk),                \

  1169.       CHECKED_CAST(stack_cmp_func,                                       \

  1170.                    int (*)(const DIST_POINT **a, const DIST_POINT **b),  \

  1171.                    comp)))

  1172. 

  1173. #define sk_DIST_POINT_deep_copy(sk, copy_func, free_func)             \

  1174.   ((STACK_OF(DIST_POINT) *)sk_deep_copy(                              \

  1175.       CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk), \

  1176.       CHECKED_CAST(void *(*)(void *), DIST_POINT *(*)(DIST_POINT *),  \

  1177.                    copy_func),                                        \

  1178.       CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func)))

  1179. 

  1180. /* GENERAL_NAME */

  1181. #define sk_GENERAL_NAME_new(comp)                                              \

  1182.   ((STACK_OF(GENERAL_NAME) *)sk_new(CHECKED_CAST(                              \

  1183.       stack_cmp_func, int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \

  1184.       comp)))

  1185. 

  1186. #define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)sk_new_null())

  1187. 

  1188. #define sk_GENERAL_NAME_num(sk) \

  1189.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))

  1190. 

  1191. #define sk_GENERAL_NAME_zero(sk) \

  1192.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk));

  1193. 

  1194. #define sk_GENERAL_NAME_value(sk, i) \

  1195.   ((GENERAL_NAME *)sk_value(         \

  1196.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk), (i)))

  1197. 

  1198. #define sk_GENERAL_NAME_set(sk, i, p)                            \

  1199.   ((GENERAL_NAME *)sk_set(                                       \

  1200.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (i), \

  1201.       CHECKED_CAST(void *, GENERAL_NAME *, p)))

  1202. 

  1203. #define sk_GENERAL_NAME_free(sk) \

  1204.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))

  1205. 

  1206. #define sk_GENERAL_NAME_pop_free(sk, free_func)             \

  1207.   sk_pop_free(                                              \

  1208.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \

  1209.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func))

  1210. 

  1211. #define sk_GENERAL_NAME_insert(sk, p, where)                      \

  1212.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \

  1213.             CHECKED_CAST(void *, GENERAL_NAME *, p), (where))

  1214. 

  1215. #define sk_GENERAL_NAME_delete(sk, where) \

  1216.   ((GENERAL_NAME *)sk_delete(             \

  1217.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (where)))

  1218. 

  1219. #define sk_GENERAL_NAME_delete_ptr(sk, p)                   \

  1220.   ((GENERAL_NAME *)sk_delete_ptr(                           \

  1221.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \

  1222.       CHECKED_CAST(void *, GENERAL_NAME *, p)))

  1223. 

  1224. #define sk_GENERAL_NAME_find(sk, out_index, p)                               \

  1225.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (out_index), \

  1226.           CHECKED_CAST(void *, GENERAL_NAME *, p))

  1227. 

  1228. #define sk_GENERAL_NAME_shift(sk) \

  1229.   ((GENERAL_NAME *)sk_shift(      \

  1230.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))

  1231. 

  1232. #define sk_GENERAL_NAME_push(sk, p)                             \

  1233.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \

  1234.           CHECKED_CAST(void *, GENERAL_NAME *, p))

  1235. 

  1236. #define sk_GENERAL_NAME_pop(sk) \

  1237.   ((GENERAL_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))

  1238. 

  1239. #define sk_GENERAL_NAME_dup(sk)      \

  1240.   ((STACK_OF(GENERAL_NAME) *)sk_dup( \

  1241.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk)))

  1242. 

  1243. #define sk_GENERAL_NAME_sort(sk) \

  1244.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))

  1245. 

  1246. #define sk_GENERAL_NAME_is_sorted(sk) \

  1247.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAME) *, sk))

  1248. 

  1249. #define sk_GENERAL_NAME_set_cmp_func(sk, comp)                               \

  1250.   ((int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b))sk_set_cmp_func( \

  1251.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk),                  \

  1252.       CHECKED_CAST(stack_cmp_func,                                           \

  1253.                    int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b),  \

  1254.                    comp)))

  1255. 

  1256. #define sk_GENERAL_NAME_deep_copy(sk, copy_func, free_func)              \

  1257.   ((STACK_OF(GENERAL_NAME) *)sk_deep_copy(                               \

  1258.       CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk),  \

  1259.       CHECKED_CAST(void *(*)(void *), GENERAL_NAME *(*)(GENERAL_NAME *), \

  1260.                    copy_func),                                           \

  1261.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func)))

  1262. 

  1263. /* GENERAL_NAMES */

  1264. #define sk_GENERAL_NAMES_new(comp)                 \

  1265.   ((STACK_OF(GENERAL_NAMES) *)sk_new(CHECKED_CAST( \

  1266.       stack_cmp_func,                              \

  1267.       int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), comp)))

  1268. 

  1269. #define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)sk_new_null())

  1270. 

  1271. #define sk_GENERAL_NAMES_num(sk) \

  1272.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))

  1273. 

  1274. #define sk_GENERAL_NAMES_zero(sk) \

  1275.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk));

  1276. 

  1277. #define sk_GENERAL_NAMES_value(sk, i) \

  1278.   ((GENERAL_NAMES *)sk_value(         \

  1279.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk), (i)))

  1280. 

  1281. #define sk_GENERAL_NAMES_set(sk, i, p)                            \

  1282.   ((GENERAL_NAMES *)sk_set(                                       \

  1283.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (i), \

  1284.       CHECKED_CAST(void *, GENERAL_NAMES *, p)))

  1285. 

  1286. #define sk_GENERAL_NAMES_free(sk) \

  1287.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))

  1288. 

  1289. #define sk_GENERAL_NAMES_pop_free(sk, free_func)             \

  1290.   sk_pop_free(                                               \

  1291.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \

  1292.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func))

  1293. 

  1294. #define sk_GENERAL_NAMES_insert(sk, p, where)                      \

  1295.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \

  1296.             CHECKED_CAST(void *, GENERAL_NAMES *, p), (where))

  1297. 

  1298. #define sk_GENERAL_NAMES_delete(sk, where) \

  1299.   ((GENERAL_NAMES *)sk_delete(             \

  1300.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (where)))

  1301. 

  1302. #define sk_GENERAL_NAMES_delete_ptr(sk, p)                   \

  1303.   ((GENERAL_NAMES *)sk_delete_ptr(                           \

  1304.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \

  1305.       CHECKED_CAST(void *, GENERAL_NAMES *, p)))

  1306. 

  1307. #define sk_GENERAL_NAMES_find(sk, out_index, p)                               \

  1308.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (out_index), \

  1309.           CHECKED_CAST(void *, GENERAL_NAMES *, p))

  1310. 

  1311. #define sk_GENERAL_NAMES_shift(sk) \

  1312.   ((GENERAL_NAMES *)sk_shift(      \

  1313.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))

  1314. 

  1315. #define sk_GENERAL_NAMES_push(sk, p)                             \

  1316.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \

  1317.           CHECKED_CAST(void *, GENERAL_NAMES *, p))

  1318. 

  1319. #define sk_GENERAL_NAMES_pop(sk) \

  1320.   ((GENERAL_NAMES *)sk_pop(      \

  1321.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))

  1322. 

  1323. #define sk_GENERAL_NAMES_dup(sk)      \

  1324.   ((STACK_OF(GENERAL_NAMES) *)sk_dup( \

  1325.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk)))

  1326. 

  1327. #define sk_GENERAL_NAMES_sort(sk) \

  1328.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))

  1329. 

  1330. #define sk_GENERAL_NAMES_is_sorted(sk) \

  1331.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_NAMES) *, sk))

  1332. 

  1333. #define sk_GENERAL_NAMES_set_cmp_func(sk, comp)                                \

  1334.   ((int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b))sk_set_cmp_func( \

  1335.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk),                   \

  1336.       CHECKED_CAST(stack_cmp_func,                                             \

  1337.                    int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b),  \

  1338.                    comp)))

  1339. 

  1340. #define sk_GENERAL_NAMES_deep_copy(sk, copy_func, free_func)               \

  1341.   ((STACK_OF(GENERAL_NAMES) *)sk_deep_copy(                                \

  1342.       CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk),   \

  1343.       CHECKED_CAST(void *(*)(void *), GENERAL_NAMES *(*)(GENERAL_NAMES *), \

  1344.                    copy_func),                                             \

  1345.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func)))

  1346. 

  1347. /* GENERAL_SUBTREE */

  1348. #define sk_GENERAL_SUBTREE_new(comp)                 \

  1349.   ((STACK_OF(GENERAL_SUBTREE) *)sk_new(CHECKED_CAST( \

  1350.       stack_cmp_func,                                \

  1351.       int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b), comp)))

  1352. 

  1353. #define sk_GENERAL_SUBTREE_new_null() \

  1354.   ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())

  1355. 

  1356. #define sk_GENERAL_SUBTREE_num(sk) \

  1357.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))

  1358. 

  1359. #define sk_GENERAL_SUBTREE_zero(sk) \

  1360.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk));

  1361. 

  1362. #define sk_GENERAL_SUBTREE_value(sk, i) \

  1363.   ((GENERAL_SUBTREE *)sk_value(         \

  1364.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk), (i)))

  1365. 

  1366. #define sk_GENERAL_SUBTREE_set(sk, i, p)                            \

  1367.   ((GENERAL_SUBTREE *)sk_set(                                       \

  1368.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (i), \

  1369.       CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))

  1370. 

  1371. #define sk_GENERAL_SUBTREE_free(sk) \

  1372.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))

  1373. 

  1374. #define sk_GENERAL_SUBTREE_pop_free(sk, free_func)             \

  1375.   sk_pop_free(                                                 \

  1376.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \

  1377.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func))

  1378. 

  1379. #define sk_GENERAL_SUBTREE_insert(sk, p, where)                      \

  1380.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \

  1381.             CHECKED_CAST(void *, GENERAL_SUBTREE *, p), (where))

  1382. 

  1383. #define sk_GENERAL_SUBTREE_delete(sk, where) \

  1384.   ((GENERAL_SUBTREE *)sk_delete(             \

  1385.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (where)))

  1386. 

  1387. #define sk_GENERAL_SUBTREE_delete_ptr(sk, p)                   \

  1388.   ((GENERAL_SUBTREE *)sk_delete_ptr(                           \

  1389.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \

  1390.       CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))

  1391. 

  1392. #define sk_GENERAL_SUBTREE_find(sk, out_index, p)                  \

  1393.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \

  1394.           (out_index), CHECKED_CAST(void *, GENERAL_SUBTREE *, p))

  1395. 

  1396. #define sk_GENERAL_SUBTREE_shift(sk) \

  1397.   ((GENERAL_SUBTREE *)sk_shift(      \

  1398.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))

  1399. 

  1400. #define sk_GENERAL_SUBTREE_push(sk, p)                             \

  1401.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \

  1402.           CHECKED_CAST(void *, GENERAL_SUBTREE *, p))

  1403. 

  1404. #define sk_GENERAL_SUBTREE_pop(sk) \

  1405.   ((GENERAL_SUBTREE *)sk_pop(      \

  1406.       CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))

  1407. 

  1408. #define sk_GENERAL_SUBTREE_dup(sk)      \

  1409.   ((STACK_OF(GENERAL_SUBTREE) *)sk_dup( \

  1410.       CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk)))

  1411. 

  1412. #define sk_GENERAL_SUBTREE_sort(sk) \

  1413.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))

  1414. 

  1415. #define sk_GENERAL_SUBTREE_is_sorted(sk) \

  1416.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))

  1417. 

  1418. #define sk_GENERAL_SUBTREE_set_cmp_func(sk, comp)                           \

  1419.   ((int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b))          \

  1420.        sk_set_cmp_func(                                                     \

  1421.            CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk),         \

  1422.            CHECKED_CAST(stack_cmp_func, int (*)(const GENERAL_SUBTREE **a,  \

  1423.                                                 const GENERAL_SUBTREE **b), \

  1424.                         comp)))

  1425. 

  1426. #define sk_GENERAL_SUBTREE_deep_copy(sk, copy_func, free_func)                 \

  1427.   ((STACK_OF(GENERAL_SUBTREE) *)sk_deep_copy(                                  \

  1428.       CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk),     \

  1429.       CHECKED_CAST(void *(*)(void *), GENERAL_SUBTREE *(*)(GENERAL_SUBTREE *), \

  1430.                    copy_func),                                                 \

  1431.       CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func)))

  1432. 

  1433. /* POLICYINFO */

  1434. #define sk_POLICYINFO_new(comp)                                            \

  1435.   ((STACK_OF(POLICYINFO) *)sk_new(CHECKED_CAST(                            \

  1436.       stack_cmp_func, int (*)(const POLICYINFO **a, const POLICYINFO **b), \

  1437.       comp)))

  1438. 

  1439. #define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)sk_new_null())

  1440. 

  1441. #define sk_POLICYINFO_num(sk) \

  1442.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))

  1443. 

  1444. #define sk_POLICYINFO_zero(sk) \

  1445.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk));

  1446. 

  1447. #define sk_POLICYINFO_value(sk, i) \

  1448.   ((POLICYINFO *)sk_value(         \

  1449.       CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk), (i)))

  1450. 

  1451. #define sk_POLICYINFO_set(sk, i, p)                                         \

  1452.   ((POLICYINFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1453.                         (i), CHECKED_CAST(void *, POLICYINFO *, p)))

  1454. 

  1455. #define sk_POLICYINFO_free(sk) \

  1456.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))

  1457. 

  1458. #define sk_POLICYINFO_pop_free(sk, free_func)             \

  1459.   sk_pop_free(                                            \

  1460.       CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1461.       CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func))

  1462. 

  1463. #define sk_POLICYINFO_insert(sk, p, where)                      \

  1464.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1465.             CHECKED_CAST(void *, POLICYINFO *, p), (where))

  1466. 

  1467. #define sk_POLICYINFO_delete(sk, where)                                        \

  1468.   ((POLICYINFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1469.                            (where)))

  1470. 

  1471. #define sk_POLICYINFO_delete_ptr(sk, p)                   \

  1472.   ((POLICYINFO *)sk_delete_ptr(                           \

  1473.       CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1474.       CHECKED_CAST(void *, POLICYINFO *, p)))

  1475. 

  1476. #define sk_POLICYINFO_find(sk, out_index, p)                               \

  1477.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), (out_index), \

  1478.           CHECKED_CAST(void *, POLICYINFO *, p))

  1479. 

  1480. #define sk_POLICYINFO_shift(sk) \

  1481.   ((POLICYINFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))

  1482. 

  1483. #define sk_POLICYINFO_push(sk, p)                             \

  1484.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \

  1485.           CHECKED_CAST(void *, POLICYINFO *, p))

  1486. 

  1487. #define sk_POLICYINFO_pop(sk) \

  1488.   ((POLICYINFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))

  1489. 

  1490. #define sk_POLICYINFO_dup(sk)      \

  1491.   ((STACK_OF(POLICYINFO) *)sk_dup( \

  1492.       CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk)))

  1493. 

  1494. #define sk_POLICYINFO_sort(sk) \

  1495.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))

  1496. 

  1497. #define sk_POLICYINFO_is_sorted(sk) \

  1498.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICYINFO) *, sk))

  1499. 

  1500. #define sk_POLICYINFO_set_cmp_func(sk, comp)                             \

  1501.   ((int (*)(const POLICYINFO **a, const POLICYINFO **b))sk_set_cmp_func( \

  1502.       CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk),                \

  1503.       CHECKED_CAST(stack_cmp_func,                                       \

  1504.                    int (*)(const POLICYINFO **a, const POLICYINFO **b),  \

  1505.                    comp)))

  1506. 

  1507. #define sk_POLICYINFO_deep_copy(sk, copy_func, free_func)             \

  1508.   ((STACK_OF(POLICYINFO) *)sk_deep_copy(                              \

  1509.       CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk), \

  1510.       CHECKED_CAST(void *(*)(void *), POLICYINFO *(*)(POLICYINFO *),  \

  1511.                    copy_func),                                        \

  1512.       CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func)))

  1513. 

  1514. /* POLICYQUALINFO */

  1515. #define sk_POLICYQUALINFO_new(comp)                 \

  1516.   ((STACK_OF(POLICYQUALINFO) *)sk_new(CHECKED_CAST( \

  1517.       stack_cmp_func,                               \

  1518.       int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b), comp)))

  1519. 

  1520. #define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)sk_new_null())

  1521. 

  1522. #define sk_POLICYQUALINFO_num(sk) \

  1523.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))

  1524. 

  1525. #define sk_POLICYQUALINFO_zero(sk) \

  1526.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk));

  1527. 

  1528. #define sk_POLICYQUALINFO_value(sk, i) \

  1529.   ((POLICYQUALINFO *)sk_value(         \

  1530.       CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk), (i)))

  1531. 

  1532. #define sk_POLICYQUALINFO_set(sk, i, p)                            \

  1533.   ((POLICYQUALINFO *)sk_set(                                       \

  1534.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (i), \

  1535.       CHECKED_CAST(void *, POLICYQUALINFO *, p)))

  1536. 

  1537. #define sk_POLICYQUALINFO_free(sk) \

  1538.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))

  1539. 

  1540. #define sk_POLICYQUALINFO_pop_free(sk, free_func)             \

  1541.   sk_pop_free(                                                \

  1542.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \

  1543.       CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func))

  1544. 

  1545. #define sk_POLICYQUALINFO_insert(sk, p, where)                      \

  1546.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \

  1547.             CHECKED_CAST(void *, POLICYQUALINFO *, p), (where))

  1548. 

  1549. #define sk_POLICYQUALINFO_delete(sk, where) \

  1550.   ((POLICYQUALINFO *)sk_delete(             \

  1551.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (where)))

  1552. 

  1553. #define sk_POLICYQUALINFO_delete_ptr(sk, p)                   \

  1554.   ((POLICYQUALINFO *)sk_delete_ptr(                           \

  1555.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \

  1556.       CHECKED_CAST(void *, POLICYQUALINFO *, p)))

  1557. 

  1558. #define sk_POLICYQUALINFO_find(sk, out_index, p)                               \

  1559.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (out_index), \

  1560.           CHECKED_CAST(void *, POLICYQUALINFO *, p))

  1561. 

  1562. #define sk_POLICYQUALINFO_shift(sk) \

  1563.   ((POLICYQUALINFO *)sk_shift(      \

  1564.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))

  1565. 

  1566. #define sk_POLICYQUALINFO_push(sk, p)                             \

  1567.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \

  1568.           CHECKED_CAST(void *, POLICYQUALINFO *, p))

  1569. 

  1570. #define sk_POLICYQUALINFO_pop(sk) \

  1571.   ((POLICYQUALINFO *)sk_pop(      \

  1572.       CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))

  1573. 

  1574. #define sk_POLICYQUALINFO_dup(sk)      \

  1575.   ((STACK_OF(POLICYQUALINFO) *)sk_dup( \

  1576.       CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk)))

  1577. 

  1578. #define sk_POLICYQUALINFO_sort(sk) \

  1579.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))

  1580. 

  1581. #define sk_POLICYQUALINFO_is_sorted(sk) \

  1582.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICYQUALINFO) *, sk))

  1583. 

  1584. #define sk_POLICYQUALINFO_set_cmp_func(sk, comp)                           \

  1585.   ((int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b))           \

  1586.        sk_set_cmp_func(                                                    \

  1587.            CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk),         \

  1588.            CHECKED_CAST(stack_cmp_func, int (*)(const POLICYQUALINFO **a,  \

  1589.                                                 const POLICYQUALINFO **b), \

  1590.                         comp)))

  1591. 

  1592. #define sk_POLICYQUALINFO_deep_copy(sk, copy_func, free_func)                \

  1593.   ((STACK_OF(POLICYQUALINFO) *)sk_deep_copy(                                 \

  1594.       CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk),    \

  1595.       CHECKED_CAST(void *(*)(void *), POLICYQUALINFO *(*)(POLICYQUALINFO *), \

  1596.                    copy_func),                                               \

  1597.       CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func)))

  1598. 

  1599. /* POLICY_MAPPING */

  1600. #define sk_POLICY_MAPPING_new(comp)                 \

  1601.   ((STACK_OF(POLICY_MAPPING) *)sk_new(CHECKED_CAST( \

  1602.       stack_cmp_func,                               \

  1603.       int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b), comp)))

  1604. 

  1605. #define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)sk_new_null())

  1606. 

  1607. #define sk_POLICY_MAPPING_num(sk) \

  1608.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))

  1609. 

  1610. #define sk_POLICY_MAPPING_zero(sk) \

  1611.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk));

  1612. 

  1613. #define sk_POLICY_MAPPING_value(sk, i) \

  1614.   ((POLICY_MAPPING *)sk_value(         \

  1615.       CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk), (i)))

  1616. 

  1617. #define sk_POLICY_MAPPING_set(sk, i, p)                            \

  1618.   ((POLICY_MAPPING *)sk_set(                                       \

  1619.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (i), \

  1620.       CHECKED_CAST(void *, POLICY_MAPPING *, p)))

  1621. 

  1622. #define sk_POLICY_MAPPING_free(sk) \

  1623.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))

  1624. 

  1625. #define sk_POLICY_MAPPING_pop_free(sk, free_func)             \

  1626.   sk_pop_free(                                                \

  1627.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \

  1628.       CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func))

  1629. 

  1630. #define sk_POLICY_MAPPING_insert(sk, p, where)                      \

  1631.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \

  1632.             CHECKED_CAST(void *, POLICY_MAPPING *, p), (where))

  1633. 

  1634. #define sk_POLICY_MAPPING_delete(sk, where) \

  1635.   ((POLICY_MAPPING *)sk_delete(             \

  1636.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (where)))

  1637. 

  1638. #define sk_POLICY_MAPPING_delete_ptr(sk, p)                   \

  1639.   ((POLICY_MAPPING *)sk_delete_ptr(                           \

  1640.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \

  1641.       CHECKED_CAST(void *, POLICY_MAPPING *, p)))

  1642. 

  1643. #define sk_POLICY_MAPPING_find(sk, out_index, p)                               \

  1644.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (out_index), \

  1645.           CHECKED_CAST(void *, POLICY_MAPPING *, p))

  1646. 

  1647. #define sk_POLICY_MAPPING_shift(sk) \

  1648.   ((POLICY_MAPPING *)sk_shift(      \

  1649.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))

  1650. 

  1651. #define sk_POLICY_MAPPING_push(sk, p)                             \

  1652.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \

  1653.           CHECKED_CAST(void *, POLICY_MAPPING *, p))

  1654. 

  1655. #define sk_POLICY_MAPPING_pop(sk) \

  1656.   ((POLICY_MAPPING *)sk_pop(      \

  1657.       CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))

  1658. 

  1659. #define sk_POLICY_MAPPING_dup(sk)      \

  1660.   ((STACK_OF(POLICY_MAPPING) *)sk_dup( \

  1661.       CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk)))

  1662. 

  1663. #define sk_POLICY_MAPPING_sort(sk) \

  1664.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))

  1665. 

  1666. #define sk_POLICY_MAPPING_is_sorted(sk) \

  1667.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(POLICY_MAPPING) *, sk))

  1668. 

  1669. #define sk_POLICY_MAPPING_set_cmp_func(sk, comp)                           \

  1670.   ((int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b))           \

  1671.        sk_set_cmp_func(                                                    \

  1672.            CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk),         \

  1673.            CHECKED_CAST(stack_cmp_func, int (*)(const POLICY_MAPPING **a,  \

  1674.                                                 const POLICY_MAPPING **b), \

  1675.                         comp)))

  1676. 

  1677. #define sk_POLICY_MAPPING_deep_copy(sk, copy_func, free_func)                \

  1678.   ((STACK_OF(POLICY_MAPPING) *)sk_deep_copy(                                 \

  1679.       CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk),    \

  1680.       CHECKED_CAST(void *(*)(void *), POLICY_MAPPING *(*)(POLICY_MAPPING *), \

  1681.                    copy_func),                                               \

  1682.       CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func)))

  1683. 

  1684. /* RSA_additional_prime */

  1685. #define sk_RSA_additional_prime_new(comp)                                      \

  1686.   ((STACK_OF(RSA_additional_prime) *)sk_new(CHECKED_CAST(                      \

  1687.       stack_cmp_func,                                                          \

  1688.       int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b), \

  1689.       comp)))

  1690. 

  1691. #define sk_RSA_additional_prime_new_null() \

  1692.   ((STACK_OF(RSA_additional_prime) *)sk_new_null())

  1693. 

  1694. #define sk_RSA_additional_prime_num(sk) \

  1695.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))

  1696. 

  1697. #define sk_RSA_additional_prime_zero(sk) \

  1698.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk));

  1699. 

  1700. #define sk_RSA_additional_prime_value(sk, i)                              \

  1701.   ((RSA_additional_prime *)sk_value(                                      \

  1702.       CHECKED_CAST(_STACK *, const STACK_OF(RSA_additional_prime) *, sk), \

  1703.       (i)))

  1704. 

  1705. #define sk_RSA_additional_prime_set(sk, i, p)                            \

  1706.   ((RSA_additional_prime *)sk_set(                                       \

  1707.       CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (i), \

  1708.       CHECKED_CAST(void *, RSA_additional_prime *, p)))

  1709. 

  1710. #define sk_RSA_additional_prime_free(sk) \

  1711.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))

  1712. 

  1713. #define sk_RSA_additional_prime_pop_free(sk, free_func)                        \

  1714.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk),    \

  1715.               CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *), \

  1716.                            free_func))

  1717. 

  1718. #define sk_RSA_additional_prime_insert(sk, p, where)                      \

  1719.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \

  1720.             CHECKED_CAST(void *, RSA_additional_prime *, p), (where))

  1721. 

  1722. #define sk_RSA_additional_prime_delete(sk, where) \

  1723.   ((RSA_additional_prime *)sk_delete(             \

  1724.       CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (where)))

  1725. 

  1726. #define sk_RSA_additional_prime_delete_ptr(sk, p)                   \

  1727.   ((RSA_additional_prime *)sk_delete_ptr(                           \

  1728.       CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \

  1729.       CHECKED_CAST(void *, RSA_additional_prime *, p)))

  1730. 

  1731. #define sk_RSA_additional_prime_find(sk, out_index, p)                  \

  1732.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \

  1733.           (out_index), CHECKED_CAST(void *, RSA_additional_prime *, p))

  1734. 

  1735. #define sk_RSA_additional_prime_shift(sk) \

  1736.   ((RSA_additional_prime *)sk_shift(      \

  1737.       CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)))

  1738. 

  1739. #define sk_RSA_additional_prime_push(sk, p)                             \

  1740.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \

  1741.           CHECKED_CAST(void *, RSA_additional_prime *, p))

  1742. 

  1743. #define sk_RSA_additional_prime_pop(sk) \

  1744.   ((RSA_additional_prime *)sk_pop(      \

  1745.       CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)))

  1746. 

  1747. #define sk_RSA_additional_prime_dup(sk)      \

  1748.   ((STACK_OF(RSA_additional_prime) *)sk_dup( \

  1749.       CHECKED_CAST(_STACK *, const STACK_OF(RSA_additional_prime) *, sk)))

  1750. 

  1751. #define sk_RSA_additional_prime_sort(sk) \

  1752.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))

  1753. 

  1754. #define sk_RSA_additional_prime_is_sorted(sk) \

  1755.   sk_is_sorted(                               \

  1756.       CHECKED_CAST(_STACK *, const STACK_OF(RSA_additional_prime) *, sk))

  1757. 

  1758. #define sk_RSA_additional_prime_set_cmp_func(sk, comp)                       \

  1759.   ((int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b)) \

  1760.        sk_set_cmp_func(                                                      \

  1761.            CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk),     \

  1762.            CHECKED_CAST(stack_cmp_func,                                      \

  1763.                         int (*)(const RSA_additional_prime **a,              \

  1764.                                 const RSA_additional_prime **b),             \

  1765.                         comp)))

  1766. 

  1767. #define sk_RSA_additional_prime_deep_copy(sk, copy_func, free_func)        \

  1768.   ((STACK_OF(RSA_additional_prime) *)sk_deep_copy(                         \

  1769.       CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \

  1770.                    sk),                                                    \

  1771.       CHECKED_CAST(void *(*)(void *),                                      \

  1772.                    RSA_additional_prime *(*)(RSA_additional_prime *),      \

  1773.                    copy_func),                                             \

  1774.       CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *),     \

  1775.                    free_func)))

  1776. 

  1777. /* SSL_COMP */

  1778. #define sk_SSL_COMP_new(comp)                 \

  1779.   ((STACK_OF(SSL_COMP) *)sk_new(CHECKED_CAST( \

  1780.       stack_cmp_func, int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))

  1781. 

  1782. #define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)sk_new_null())

  1783. 

  1784. #define sk_SSL_COMP_num(sk) \

  1785.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))

  1786. 

  1787. #define sk_SSL_COMP_zero(sk) \

  1788.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk));

  1789. 

  1790. #define sk_SSL_COMP_value(sk, i) \

  1791.   ((SSL_COMP *)sk_value(         \

  1792.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk), (i)))

  1793. 

  1794. #define sk_SSL_COMP_set(sk, i, p)                                            \

  1795.   ((SSL_COMP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (i), \

  1796.                       CHECKED_CAST(void *, SSL_COMP *, p)))

  1797. 

  1798. #define sk_SSL_COMP_free(sk) \

  1799.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))

  1800. 

  1801. #define sk_SSL_COMP_pop_free(sk, free_func)                     \

  1802.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  1803.               CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func))

  1804. 

  1805. #define sk_SSL_COMP_insert(sk, p, where)                      \

  1806.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  1807.             CHECKED_CAST(void *, SSL_COMP *, p), (where))

  1808. 

  1809. #define sk_SSL_COMP_delete(sk, where)                                      \

  1810.   ((SSL_COMP *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  1811.                          (where)))

  1812. 

  1813. #define sk_SSL_COMP_delete_ptr(sk, p)                                          \

  1814.   ((SSL_COMP *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  1815.                              CHECKED_CAST(void *, SSL_COMP *, p)))

  1816. 

  1817. #define sk_SSL_COMP_find(sk, out_index, p)                               \

  1818.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (out_index), \

  1819.           CHECKED_CAST(void *, SSL_COMP *, p))

  1820. 

  1821. #define sk_SSL_COMP_shift(sk) \

  1822.   ((SSL_COMP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))

  1823. 

  1824. #define sk_SSL_COMP_push(sk, p)                             \

  1825.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  1826.           CHECKED_CAST(void *, SSL_COMP *, p))

  1827. 

  1828. #define sk_SSL_COMP_pop(sk) \

  1829.   ((SSL_COMP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))

  1830. 

  1831. #define sk_SSL_COMP_dup(sk)      \

  1832.   ((STACK_OF(SSL_COMP) *)sk_dup( \

  1833.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk)))

  1834. 

  1835. #define sk_SSL_COMP_sort(sk) \

  1836.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))

  1837. 

  1838. #define sk_SSL_COMP_is_sorted(sk) \

  1839.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk))

  1840. 

  1841. #define sk_SSL_COMP_set_cmp_func(sk, comp)                           \

  1842.   ((int (*)(const SSL_COMP **a, const SSL_COMP **b))sk_set_cmp_func( \

  1843.       CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk),              \

  1844.       CHECKED_CAST(stack_cmp_func,                                   \

  1845.                    int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))

  1846. 

  1847. #define sk_SSL_COMP_deep_copy(sk, copy_func, free_func)                      \

  1848.   ((STACK_OF(SSL_COMP) *)sk_deep_copy(                                       \

  1849.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk),          \

  1850.       CHECKED_CAST(void *(*)(void *), SSL_COMP *(*)(SSL_COMP *), copy_func), \

  1851.       CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func)))

  1852. 

  1853. /* SSL_CUSTOM_EXTENSION */

  1854. #define sk_SSL_CUSTOM_EXTENSION_new(comp)                                      \

  1855.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new(CHECKED_CAST(                      \

  1856.       stack_cmp_func,                                                          \

  1857.       int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b), \

  1858.       comp)))

  1859. 

  1860. #define sk_SSL_CUSTOM_EXTENSION_new_null() \

  1861.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null())

  1862. 

  1863. #define sk_SSL_CUSTOM_EXTENSION_num(sk) \

  1864.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  1865. 

  1866. #define sk_SSL_CUSTOM_EXTENSION_zero(sk) \

  1867.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk));

  1868. 

  1869. #define sk_SSL_CUSTOM_EXTENSION_value(sk, i)                              \

  1870.   ((SSL_CUSTOM_EXTENSION *)sk_value(                                      \

  1871.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1872.       (i)))

  1873. 

  1874. #define sk_SSL_CUSTOM_EXTENSION_set(sk, i, p)                            \

  1875.   ((SSL_CUSTOM_EXTENSION *)sk_set(                                       \

  1876.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (i), \

  1877.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  1878. 

  1879. #define sk_SSL_CUSTOM_EXTENSION_free(sk) \

  1880.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  1881. 

  1882. #define sk_SSL_CUSTOM_EXTENSION_pop_free(sk, free_func)                        \

  1883.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),    \

  1884.               CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \

  1885.                            free_func))

  1886. 

  1887. #define sk_SSL_CUSTOM_EXTENSION_insert(sk, p, where)                      \

  1888.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1889.             CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p), (where))

  1890. 

  1891. #define sk_SSL_CUSTOM_EXTENSION_delete(sk, where) \

  1892.   ((SSL_CUSTOM_EXTENSION *)sk_delete(             \

  1893.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (where)))

  1894. 

  1895. #define sk_SSL_CUSTOM_EXTENSION_delete_ptr(sk, p)                   \

  1896.   ((SSL_CUSTOM_EXTENSION *)sk_delete_ptr(                           \

  1897.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1898.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  1899. 

  1900. #define sk_SSL_CUSTOM_EXTENSION_find(sk, out_index, p)                  \

  1901.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1902.           (out_index), CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  1903. 

  1904. #define sk_SSL_CUSTOM_EXTENSION_shift(sk) \

  1905.   ((SSL_CUSTOM_EXTENSION *)sk_shift(      \

  1906.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  1907. 

  1908. #define sk_SSL_CUSTOM_EXTENSION_push(sk, p)                             \

  1909.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1910.           CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  1911. 

  1912. #define sk_SSL_CUSTOM_EXTENSION_pop(sk) \

  1913.   ((SSL_CUSTOM_EXTENSION *)sk_pop(      \

  1914.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  1915. 

  1916. #define sk_SSL_CUSTOM_EXTENSION_dup(sk)      \

  1917.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_dup( \

  1918.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  1919. 

  1920. #define sk_SSL_CUSTOM_EXTENSION_sort(sk) \

  1921.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  1922. 

  1923. #define sk_SSL_CUSTOM_EXTENSION_is_sorted(sk) \

  1924.   sk_is_sorted(                               \

  1925.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  1926. 

  1927. #define sk_SSL_CUSTOM_EXTENSION_set_cmp_func(sk, comp)                       \

  1928.   ((int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b)) \

  1929.        sk_set_cmp_func(                                                      \

  1930.            CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),     \

  1931.            CHECKED_CAST(stack_cmp_func,                                      \

  1932.                         int (*)(const SSL_CUSTOM_EXTENSION **a,              \

  1933.                                 const SSL_CUSTOM_EXTENSION **b),             \

  1934.                         comp)))

  1935. 

  1936. #define sk_SSL_CUSTOM_EXTENSION_deep_copy(sk, copy_func, free_func)        \

  1937.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_deep_copy(                         \

  1938.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \

  1939.                    sk),                                                    \

  1940.       CHECKED_CAST(void *(*)(void *),                                      \

  1941.                    SSL_CUSTOM_EXTENSION *(*)(SSL_CUSTOM_EXTENSION *),      \

  1942.                    copy_func),                                             \

  1943.       CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *),     \

  1944.                    free_func)))

  1945. 

  1946. /* STACK_OF_X509_NAME_ENTRY */

  1947. #define sk_STACK_OF_X509_NAME_ENTRY_new(comp)                      \

  1948.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST(      \

  1949.       stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a,  \

  1950.                               const STACK_OF_X509_NAME_ENTRY **b), \

  1951.       comp)))

  1952. 

  1953. #define sk_STACK_OF_X509_NAME_ENTRY_new_null() \

  1954.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())

  1955. 

  1956. #define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \

  1957.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  1958. 

  1959. #define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \

  1960.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk));

  1961. 

  1962. #define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i)                              \

  1963.   ((STACK_OF_X509_NAME_ENTRY *)sk_value(                                      \

  1964.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1965.       (i)))

  1966. 

  1967. #define sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p)                            \

  1968.   ((STACK_OF_X509_NAME_ENTRY *)sk_set(                                       \

  1969.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \

  1970.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  1971. 

  1972. #define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \

  1973.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  1974. 

  1975. #define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func)                \

  1976.   sk_pop_free(                                                             \

  1977.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk),    \

  1978.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \

  1979.                    free_func))

  1980. 

  1981. #define sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where)                      \

  1982.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1983.             CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where))

  1984. 

  1985. #define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where)                   \

  1986.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete(                               \

  1987.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1988.       (where)))

  1989. 

  1990. #define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  1991.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr(                           \

  1992.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1993.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  1994. 

  1995. #define sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  1996.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1997.           (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  1998. 

  1999. #define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \

  2000.   ((STACK_OF_X509_NAME_ENTRY *)sk_shift(      \

  2001.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2002. 

  2003. #define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p)                             \

  2004.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2005.           CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  2006. 

  2007. #define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \

  2008.   ((STACK_OF_X509_NAME_ENTRY *)sk_pop(      \

  2009.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2010. 

  2011. #define sk_STACK_OF_X509_NAME_ENTRY_dup(sk)      \

  2012.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup( \

  2013.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2014. 

  2015. #define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \

  2016.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2017. 

  2018. #define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \

  2019.   sk_is_sorted(                                   \

  2020.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2021. 

  2022. #define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp)                   \

  2023.   ((int (*)(const STACK_OF_X509_NAME_ENTRY **a,                              \

  2024.             const STACK_OF_X509_NAME_ENTRY **b))                             \

  2025.        sk_set_cmp_func(                                                      \

  2026.            CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2027.            CHECKED_CAST(stack_cmp_func,                                      \

  2028.                         int (*)(const STACK_OF_X509_NAME_ENTRY **a,          \

  2029.                                 const STACK_OF_X509_NAME_ENTRY **b),         \

  2030.                         comp)))

  2031. 

  2032. #define sk_STACK_OF_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)        \

  2033.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_deep_copy(                         \

  2034.       CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \

  2035.                    sk),                                                        \

  2036.       CHECKED_CAST(void *(*)(void *),                                          \

  2037.                    STACK_OF_X509_NAME_ENTRY *(*)(STACK_OF_X509_NAME_ENTRY *),  \

  2038.                    copy_func),                                                 \

  2039.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *),     \

  2040.                    free_func)))

  2041. 

  2042. /* SXNETID */

  2043. #define sk_SXNETID_new(comp)                 \

  2044.   ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \

  2045.       stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2046. 

  2047. #define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null())

  2048. 

  2049. #define sk_SXNETID_num(sk) \

  2050.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2051. 

  2052. #define sk_SXNETID_zero(sk) \

  2053.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));

  2054. 

  2055. #define sk_SXNETID_value(sk, i)                                               \

  2056.   ((SXNETID *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk), \

  2057.                        (i)))

  2058. 

  2059. #define sk_SXNETID_set(sk, i, p)                                           \

  2060.   ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \

  2061.                      CHECKED_CAST(void *, SXNETID *, p)))

  2062. 

  2063. #define sk_SXNETID_free(sk) \

  2064.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2065. 

  2066. #define sk_SXNETID_pop_free(sk, free_func)                     \

  2067.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2068.               CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))

  2069. 

  2070. #define sk_SXNETID_insert(sk, p, where)                      \

  2071.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2072.             CHECKED_CAST(void *, SXNETID *, p), (where))

  2073. 

  2074. #define sk_SXNETID_delete(sk, where)                                     \

  2075.   ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2076.                         (where)))

  2077. 

  2078. #define sk_SXNETID_delete_ptr(sk, p)                                         \

  2079.   ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2080.                             CHECKED_CAST(void *, SXNETID *, p)))

  2081. 

  2082. #define sk_SXNETID_find(sk, out_index, p)                               \

  2083.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \

  2084.           CHECKED_CAST(void *, SXNETID *, p))

  2085. 

  2086. #define sk_SXNETID_shift(sk) \

  2087.   ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2088. 

  2089. #define sk_SXNETID_push(sk, p)                             \

  2090.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2091.           CHECKED_CAST(void *, SXNETID *, p))

  2092. 

  2093. #define sk_SXNETID_pop(sk) \

  2094.   ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2095. 

  2096. #define sk_SXNETID_dup(sk)      \

  2097.   ((STACK_OF(SXNETID) *)sk_dup( \

  2098.       CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk)))

  2099. 

  2100. #define sk_SXNETID_sort(sk) \

  2101.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2102. 

  2103. #define sk_SXNETID_is_sorted(sk) \

  2104.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk))

  2105. 

  2106. #define sk_SXNETID_set_cmp_func(sk, comp)                          \

  2107.   ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \

  2108.       CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk),             \

  2109.       CHECKED_CAST(stack_cmp_func,                                 \

  2110.                    int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2111. 

  2112. #define sk_SXNETID_deep_copy(sk, copy_func, free_func)                     \

  2113.   ((STACK_OF(SXNETID) *)sk_deep_copy(                                      \

  2114.       CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk),         \

  2115.       CHECKED_CAST(void *(*)(void *), SXNETID *(*)(SXNETID *), copy_func), \

  2116.       CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func)))

  2117. 

  2118. /* X509 */

  2119. #define sk_X509_new(comp)                 \

  2120.   ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \

  2121.       stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))

  2122. 

  2123. #define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null())

  2124. 

  2125. #define sk_X509_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2126. 

  2127. #define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));

  2128. 

  2129. #define sk_X509_value(sk, i) \

  2130.   ((X509 *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk), (i)))

  2131. 

  2132. #define sk_X509_set(sk, i, p)                                        \

  2133.   ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \

  2134.                   CHECKED_CAST(void *, X509 *, p)))

  2135. 

  2136. #define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2137. 

  2138. #define sk_X509_pop_free(sk, free_func)                     \

  2139.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2140.               CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))

  2141. 

  2142. #define sk_X509_insert(sk, p, where)                      \

  2143.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2144.             CHECKED_CAST(void *, X509 *, p), (where))

  2145. 

  2146. #define sk_X509_delete(sk, where) \

  2147.   ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))

  2148. 

  2149. #define sk_X509_delete_ptr(sk, p)                                      \

  2150.   ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2151.                          CHECKED_CAST(void *, X509 *, p)))

  2152. 

  2153. #define sk_X509_find(sk, out_index, p)                               \

  2154.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \

  2155.           CHECKED_CAST(void *, X509 *, p))

  2156. 

  2157. #define sk_X509_shift(sk) \

  2158.   ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2159. 

  2160. #define sk_X509_push(sk, p)                             \

  2161.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2162.           CHECKED_CAST(void *, X509 *, p))

  2163. 

  2164. #define sk_X509_pop(sk) \

  2165.   ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2166. 

  2167. #define sk_X509_dup(sk) \

  2168.   ((STACK_OF(X509) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk)))

  2169. 

  2170. #define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2171. 

  2172. #define sk_X509_is_sorted(sk) \

  2173.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk))

  2174. 

  2175. #define sk_X509_set_cmp_func(sk, comp)                                      \

  2176.   ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func(                \

  2177.       CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk),                         \

  2178.       CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \

  2179.                    comp)))

  2180. 

  2181. #define sk_X509_deep_copy(sk, copy_func, free_func)                  \

  2182.   ((STACK_OF(X509) *)sk_deep_copy(                                   \

  2183.       CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk),      \

  2184.       CHECKED_CAST(void *(*)(void *), X509 *(*)(X509 *), copy_func), \

  2185.       CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func)))

  2186. 

  2187. /* X509V3_EXT_METHOD */

  2188. #define sk_X509V3_EXT_METHOD_new(comp)                                   \

  2189.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST(                   \

  2190.       stack_cmp_func,                                                    \

  2191.       int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \

  2192.       comp)))

  2193. 

  2194. #define sk_X509V3_EXT_METHOD_new_null() \

  2195.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())

  2196. 

  2197. #define sk_X509V3_EXT_METHOD_num(sk) \

  2198.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2199. 

  2200. #define sk_X509V3_EXT_METHOD_zero(sk) \

  2201.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));

  2202. 

  2203. #define sk_X509V3_EXT_METHOD_value(sk, i) \

  2204.   ((X509V3_EXT_METHOD *)sk_value(         \

  2205.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), (i)))

  2206. 

  2207. #define sk_X509V3_EXT_METHOD_set(sk, i, p)                            \

  2208.   ((X509V3_EXT_METHOD *)sk_set(                                       \

  2209.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \

  2210.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2211. 

  2212. #define sk_X509V3_EXT_METHOD_free(sk) \

  2213.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2214. 

  2215. #define sk_X509V3_EXT_METHOD_pop_free(sk, free_func)                        \

  2216.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),    \

  2217.               CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \

  2218.                            free_func))

  2219. 

  2220. #define sk_X509V3_EXT_METHOD_insert(sk, p, where)                      \

  2221.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2222.             CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))

  2223. 

  2224. #define sk_X509V3_EXT_METHOD_delete(sk, where) \

  2225.   ((X509V3_EXT_METHOD *)sk_delete(             \

  2226.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))

  2227. 

  2228. #define sk_X509V3_EXT_METHOD_delete_ptr(sk, p)                   \

  2229.   ((X509V3_EXT_METHOD *)sk_delete_ptr(                           \

  2230.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2231.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2232. 

  2233. #define sk_X509V3_EXT_METHOD_find(sk, out_index, p)                  \

  2234.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2235.           (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2236. 

  2237. #define sk_X509V3_EXT_METHOD_shift(sk) \

  2238.   ((X509V3_EXT_METHOD *)sk_shift(      \

  2239.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2240. 

  2241. #define sk_X509V3_EXT_METHOD_push(sk, p)                             \

  2242.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2243.           CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2244. 

  2245. #define sk_X509V3_EXT_METHOD_pop(sk) \

  2246.   ((X509V3_EXT_METHOD *)sk_pop(      \

  2247.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2248. 

  2249. #define sk_X509V3_EXT_METHOD_dup(sk)      \

  2250.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \

  2251.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2252. 

  2253. #define sk_X509V3_EXT_METHOD_sort(sk) \

  2254.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2255. 

  2256. #define sk_X509V3_EXT_METHOD_is_sorted(sk) \

  2257.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

  2258. 

  2259. #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp)                           \

  2260.   ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b))        \

  2261.        sk_set_cmp_func(                                                       \

  2262.            CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),         \

  2263.            CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a,  \

  2264.                                                 const X509V3_EXT_METHOD **b), \

  2265.                         comp)))

  2266. 

  2267. #define sk_X509V3_EXT_METHOD_deep_copy(sk, copy_func, free_func)             \

  2268.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_deep_copy(                              \

  2269.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2270.       CHECKED_CAST(void *(*)(void *),                                        \

  2271.                    X509V3_EXT_METHOD *(*)(X509V3_EXT_METHOD *), copy_func),  \

  2272.       CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *),          \

  2273.                    free_func)))

  2274. 

  2275. /* X509_ALGOR */

  2276. #define sk_X509_ALGOR_new(comp)                                            \

  2277.   ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST(                            \

  2278.       stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \

  2279.       comp)))

  2280. 

  2281. #define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null())

  2282. 

  2283. #define sk_X509_ALGOR_num(sk) \

  2284.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2285. 

  2286. #define sk_X509_ALGOR_zero(sk) \

  2287.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));

  2288. 

  2289. #define sk_X509_ALGOR_value(sk, i) \

  2290.   ((X509_ALGOR *)sk_value(         \

  2291.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))

  2292. 

  2293. #define sk_X509_ALGOR_set(sk, i, p)                                         \

  2294.   ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2295.                         (i), CHECKED_CAST(void *, X509_ALGOR *, p)))

  2296. 

  2297. #define sk_X509_ALGOR_free(sk) \

  2298.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2299. 

  2300. #define sk_X509_ALGOR_pop_free(sk, free_func)             \

  2301.   sk_pop_free(                                            \

  2302.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2303.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))

  2304. 

  2305. #define sk_X509_ALGOR_insert(sk, p, where)                      \

  2306.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2307.             CHECKED_CAST(void *, X509_ALGOR *, p), (where))

  2308. 

  2309. #define sk_X509_ALGOR_delete(sk, where)                                        \

  2310.   ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2311.                            (where)))

  2312. 

  2313. #define sk_X509_ALGOR_delete_ptr(sk, p)                   \

  2314.   ((X509_ALGOR *)sk_delete_ptr(                           \

  2315.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2316.       CHECKED_CAST(void *, X509_ALGOR *, p)))

  2317. 

  2318. #define sk_X509_ALGOR_find(sk, out_index, p)                               \

  2319.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \

  2320.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2321. 

  2322. #define sk_X509_ALGOR_shift(sk) \

  2323.   ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2324. 

  2325. #define sk_X509_ALGOR_push(sk, p)                             \

  2326.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2327.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2328. 

  2329. #define sk_X509_ALGOR_pop(sk) \

  2330.   ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2331. 

  2332. #define sk_X509_ALGOR_dup(sk)      \

  2333.   ((STACK_OF(X509_ALGOR) *)sk_dup( \

  2334.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk)))

  2335. 

  2336. #define sk_X509_ALGOR_sort(sk) \

  2337.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2338. 

  2339. #define sk_X509_ALGOR_is_sorted(sk) \

  2340.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk))

  2341. 

  2342. #define sk_X509_ALGOR_set_cmp_func(sk, comp)                             \

  2343.   ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \

  2344.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk),                \

  2345.       CHECKED_CAST(stack_cmp_func,                                       \

  2346.                    int (*)(const X509_ALGOR **a, const X509_ALGOR **b),  \

  2347.                    comp)))

  2348. 

  2349. #define sk_X509_ALGOR_deep_copy(sk, copy_func, free_func)             \

  2350.   ((STACK_OF(X509_ALGOR) *)sk_deep_copy(                              \

  2351.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), \

  2352.       CHECKED_CAST(void *(*)(void *), X509_ALGOR *(*)(X509_ALGOR *),  \

  2353.                    copy_func),                                        \

  2354.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func)))

  2355. 

  2356. /* X509_ATTRIBUTE */

  2357. #define sk_X509_ATTRIBUTE_new(comp)                 \

  2358.   ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \

  2359.       stack_cmp_func,                               \

  2360.       int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))

  2361. 

  2362. #define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())

  2363. 

  2364. #define sk_X509_ATTRIBUTE_num(sk) \

  2365.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2366. 

  2367. #define sk_X509_ATTRIBUTE_zero(sk) \

  2368.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));

  2369. 

  2370. #define sk_X509_ATTRIBUTE_value(sk, i) \

  2371.   ((X509_ATTRIBUTE *)sk_value(         \

  2372.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), (i)))

  2373. 

  2374. #define sk_X509_ATTRIBUTE_set(sk, i, p)                            \

  2375.   ((X509_ATTRIBUTE *)sk_set(                                       \

  2376.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \

  2377.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2378. 

  2379. #define sk_X509_ATTRIBUTE_free(sk) \

  2380.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2381. 

  2382. #define sk_X509_ATTRIBUTE_pop_free(sk, free_func)             \

  2383.   sk_pop_free(                                                \

  2384.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2385.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))

  2386. 

  2387. #define sk_X509_ATTRIBUTE_insert(sk, p, where)                      \

  2388.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2389.             CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))

  2390. 

  2391. #define sk_X509_ATTRIBUTE_delete(sk, where) \

  2392.   ((X509_ATTRIBUTE *)sk_delete(             \

  2393.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))

  2394. 

  2395. #define sk_X509_ATTRIBUTE_delete_ptr(sk, p)                   \

  2396.   ((X509_ATTRIBUTE *)sk_delete_ptr(                           \

  2397.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2398.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2399. 

  2400. #define sk_X509_ATTRIBUTE_find(sk, out_index, p)                               \

  2401.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \

  2402.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2403. 

  2404. #define sk_X509_ATTRIBUTE_shift(sk) \

  2405.   ((X509_ATTRIBUTE *)sk_shift(      \

  2406.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2407. 

  2408. #define sk_X509_ATTRIBUTE_push(sk, p)                             \

  2409.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2410.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2411. 

  2412. #define sk_X509_ATTRIBUTE_pop(sk) \

  2413.   ((X509_ATTRIBUTE *)sk_pop(      \

  2414.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2415. 

  2416. #define sk_X509_ATTRIBUTE_dup(sk)      \

  2417.   ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \

  2418.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))

  2419. 

  2420. #define sk_X509_ATTRIBUTE_sort(sk) \

  2421.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2422. 

  2423. #define sk_X509_ATTRIBUTE_is_sorted(sk) \

  2424.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

  2425. 

  2426. #define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp)                           \

  2427.   ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b))           \

  2428.        sk_set_cmp_func(                                                    \

  2429.            CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk),         \

  2430.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a,  \

  2431.                                                 const X509_ATTRIBUTE **b), \

  2432.                         comp)))

  2433. 

  2434. #define sk_X509_ATTRIBUTE_deep_copy(sk, copy_func, free_func)                \

  2435.   ((STACK_OF(X509_ATTRIBUTE) *)sk_deep_copy(                                 \

  2436.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk),    \

  2437.       CHECKED_CAST(void *(*)(void *), X509_ATTRIBUTE *(*)(X509_ATTRIBUTE *), \

  2438.                    copy_func),                                               \

  2439.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func)))

  2440. 

  2441. /* X509_CRL */

  2442. #define sk_X509_CRL_new(comp)                 \

  2443.   ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \

  2444.       stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2445. 

  2446. #define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null())

  2447. 

  2448. #define sk_X509_CRL_num(sk) \

  2449.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2450. 

  2451. #define sk_X509_CRL_zero(sk) \

  2452.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));

  2453. 

  2454. #define sk_X509_CRL_value(sk, i) \

  2455.   ((X509_CRL *)sk_value(         \

  2456.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk), (i)))

  2457. 

  2458. #define sk_X509_CRL_set(sk, i, p)                                            \

  2459.   ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \

  2460.                       CHECKED_CAST(void *, X509_CRL *, p)))

  2461. 

  2462. #define sk_X509_CRL_free(sk) \

  2463.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2464. 

  2465. #define sk_X509_CRL_pop_free(sk, free_func)                     \

  2466.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2467.               CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))

  2468. 

  2469. #define sk_X509_CRL_insert(sk, p, where)                      \

  2470.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2471.             CHECKED_CAST(void *, X509_CRL *, p), (where))

  2472. 

  2473. #define sk_X509_CRL_delete(sk, where)                                      \

  2474.   ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2475.                          (where)))

  2476. 

  2477. #define sk_X509_CRL_delete_ptr(sk, p)                                          \

  2478.   ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2479.                              CHECKED_CAST(void *, X509_CRL *, p)))

  2480. 

  2481. #define sk_X509_CRL_find(sk, out_index, p)                               \

  2482.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \

  2483.           CHECKED_CAST(void *, X509_CRL *, p))

  2484. 

  2485. #define sk_X509_CRL_shift(sk) \

  2486.   ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2487. 

  2488. #define sk_X509_CRL_push(sk, p)                             \

  2489.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2490.           CHECKED_CAST(void *, X509_CRL *, p))

  2491. 

  2492. #define sk_X509_CRL_pop(sk) \

  2493.   ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2494. 

  2495. #define sk_X509_CRL_dup(sk)      \

  2496.   ((STACK_OF(X509_CRL) *)sk_dup( \

  2497.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk)))

  2498. 

  2499. #define sk_X509_CRL_sort(sk) \

  2500.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2501. 

  2502. #define sk_X509_CRL_is_sorted(sk) \

  2503.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk))

  2504. 

  2505. #define sk_X509_CRL_set_cmp_func(sk, comp)                           \

  2506.   ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \

  2507.       CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk),              \

  2508.       CHECKED_CAST(stack_cmp_func,                                   \

  2509.                    int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2510. 

  2511. #define sk_X509_CRL_deep_copy(sk, copy_func, free_func)                      \

  2512.   ((STACK_OF(X509_CRL) *)sk_deep_copy(                                       \

  2513.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk),          \

  2514.       CHECKED_CAST(void *(*)(void *), X509_CRL *(*)(X509_CRL *), copy_func), \

  2515.       CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func)))

  2516. 

  2517. /* X509_EXTENSION */

  2518. #define sk_X509_EXTENSION_new(comp)                 \

  2519.   ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \

  2520.       stack_cmp_func,                               \

  2521.       int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))

  2522. 

  2523. #define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null())

  2524. 

  2525. #define sk_X509_EXTENSION_num(sk) \

  2526.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2527. 

  2528. #define sk_X509_EXTENSION_zero(sk) \

  2529.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));

  2530. 

  2531. #define sk_X509_EXTENSION_value(sk, i) \

  2532.   ((X509_EXTENSION *)sk_value(         \

  2533.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk), (i)))

  2534. 

  2535. #define sk_X509_EXTENSION_set(sk, i, p)                            \

  2536.   ((X509_EXTENSION *)sk_set(                                       \

  2537.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \

  2538.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2539. 

  2540. #define sk_X509_EXTENSION_free(sk) \

  2541.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2542. 

  2543. #define sk_X509_EXTENSION_pop_free(sk, free_func)             \

  2544.   sk_pop_free(                                                \

  2545.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2546.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))

  2547. 

  2548. #define sk_X509_EXTENSION_insert(sk, p, where)                      \

  2549.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2550.             CHECKED_CAST(void *, X509_EXTENSION *, p), (where))

  2551. 

  2552. #define sk_X509_EXTENSION_delete(sk, where) \

  2553.   ((X509_EXTENSION *)sk_delete(             \

  2554.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))

  2555. 

  2556. #define sk_X509_EXTENSION_delete_ptr(sk, p)                   \

  2557.   ((X509_EXTENSION *)sk_delete_ptr(                           \

  2558.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2559.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2560. 

  2561. #define sk_X509_EXTENSION_find(sk, out_index, p)                               \

  2562.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \

  2563.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2564. 

  2565. #define sk_X509_EXTENSION_shift(sk) \

  2566.   ((X509_EXTENSION *)sk_shift(      \

  2567.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2568. 

  2569. #define sk_X509_EXTENSION_push(sk, p)                             \

  2570.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2571.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2572. 

  2573. #define sk_X509_EXTENSION_pop(sk) \

  2574.   ((X509_EXTENSION *)sk_pop(      \

  2575.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2576. 

  2577. #define sk_X509_EXTENSION_dup(sk)      \

  2578.   ((STACK_OF(X509_EXTENSION) *)sk_dup( \

  2579.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk)))

  2580. 

  2581. #define sk_X509_EXTENSION_sort(sk) \

  2582.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2583. 

  2584. #define sk_X509_EXTENSION_is_sorted(sk) \

  2585.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk))

  2586. 

  2587. #define sk_X509_EXTENSION_set_cmp_func(sk, comp)                           \

  2588.   ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b))           \

  2589.        sk_set_cmp_func(                                                    \

  2590.            CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk),         \

  2591.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a,  \

  2592.                                                 const X509_EXTENSION **b), \

  2593.                         comp)))

  2594. 

  2595. #define sk_X509_EXTENSION_deep_copy(sk, copy_func, free_func)                \

  2596.   ((STACK_OF(X509_EXTENSION) *)sk_deep_copy(                                 \

  2597.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk),    \

  2598.       CHECKED_CAST(void *(*)(void *), X509_EXTENSION *(*)(X509_EXTENSION *), \

  2599.                    copy_func),                                               \

  2600.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func)))

  2601. 

  2602. /* X509_INFO */

  2603. #define sk_X509_INFO_new(comp)     \

  2604.   ((STACK_OF(X509_INFO) *)sk_new(  \

  2605.       CHECKED_CAST(stack_cmp_func, \

  2606.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2607. 

  2608. #define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null())

  2609. 

  2610. #define sk_X509_INFO_num(sk) \

  2611.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2612. 

  2613. #define sk_X509_INFO_zero(sk) \

  2614.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));

  2615. 

  2616. #define sk_X509_INFO_value(sk, i) \

  2617.   ((X509_INFO *)sk_value(         \

  2618.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk), (i)))

  2619. 

  2620. #define sk_X509_INFO_set(sk, i, p)                                             \

  2621.   ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \

  2622.                        CHECKED_CAST(void *, X509_INFO *, p)))

  2623. 

  2624. #define sk_X509_INFO_free(sk) \

  2625.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2626. 

  2627. #define sk_X509_INFO_pop_free(sk, free_func)             \

  2628.   sk_pop_free(                                           \

  2629.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2630.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))

  2631. 

  2632. #define sk_X509_INFO_insert(sk, p, where)                      \

  2633.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2634.             CHECKED_CAST(void *, X509_INFO *, p), (where))

  2635. 

  2636. #define sk_X509_INFO_delete(sk, where)                                       \

  2637.   ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2638.                           (where)))

  2639. 

  2640. #define sk_X509_INFO_delete_ptr(sk, p)                   \

  2641.   ((X509_INFO *)sk_delete_ptr(                           \

  2642.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2643.       CHECKED_CAST(void *, X509_INFO *, p)))

  2644. 

  2645. #define sk_X509_INFO_find(sk, out_index, p)                               \

  2646.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \

  2647.           CHECKED_CAST(void *, X509_INFO *, p))

  2648. 

  2649. #define sk_X509_INFO_shift(sk) \

  2650.   ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2651. 

  2652. #define sk_X509_INFO_push(sk, p)                             \

  2653.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2654.           CHECKED_CAST(void *, X509_INFO *, p))

  2655. 

  2656. #define sk_X509_INFO_pop(sk) \

  2657.   ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2658. 

  2659. #define sk_X509_INFO_dup(sk)      \

  2660.   ((STACK_OF(X509_INFO) *)sk_dup( \

  2661.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk)))

  2662. 

  2663. #define sk_X509_INFO_sort(sk) \

  2664.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2665. 

  2666. #define sk_X509_INFO_is_sorted(sk) \

  2667.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk))

  2668. 

  2669. #define sk_X509_INFO_set_cmp_func(sk, comp)                            \

  2670.   ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \

  2671.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk),               \

  2672.       CHECKED_CAST(stack_cmp_func,                                     \

  2673.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2674. 

  2675. #define sk_X509_INFO_deep_copy(sk, copy_func, free_func)                       \

  2676.   ((STACK_OF(X509_INFO) *)sk_deep_copy(                                        \

  2677.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk),           \

  2678.       CHECKED_CAST(void *(*)(void *), X509_INFO *(*)(X509_INFO *), copy_func), \

  2679.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func)))

  2680. 

  2681. /* X509_LOOKUP */

  2682. #define sk_X509_LOOKUP_new(comp)                                             \

  2683.   ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST(                             \

  2684.       stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \

  2685.       comp)))

  2686. 

  2687. #define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null())

  2688. 

  2689. #define sk_X509_LOOKUP_num(sk) \

  2690.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2691. 

  2692. #define sk_X509_LOOKUP_zero(sk) \

  2693.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));

  2694. 

  2695. #define sk_X509_LOOKUP_value(sk, i) \

  2696.   ((X509_LOOKUP *)sk_value(         \

  2697.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))

  2698. 

  2699. #define sk_X509_LOOKUP_set(sk, i, p)                                          \

  2700.   ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2701.                          (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2702. 

  2703. #define sk_X509_LOOKUP_free(sk) \

  2704.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2705. 

  2706. #define sk_X509_LOOKUP_pop_free(sk, free_func)             \

  2707.   sk_pop_free(                                             \

  2708.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2709.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))

  2710. 

  2711. #define sk_X509_LOOKUP_insert(sk, p, where)                      \

  2712.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2713.             CHECKED_CAST(void *, X509_LOOKUP *, p), (where))

  2714. 

  2715. #define sk_X509_LOOKUP_delete(sk, where) \

  2716.   ((X509_LOOKUP *)sk_delete(             \

  2717.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))

  2718. 

  2719. #define sk_X509_LOOKUP_delete_ptr(sk, p)                   \

  2720.   ((X509_LOOKUP *)sk_delete_ptr(                           \

  2721.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2722.       CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2723. 

  2724. #define sk_X509_LOOKUP_find(sk, out_index, p)                               \

  2725.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \

  2726.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2727. 

  2728. #define sk_X509_LOOKUP_shift(sk) \

  2729.   ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2730. 

  2731. #define sk_X509_LOOKUP_push(sk, p)                             \

  2732.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2733.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2734. 

  2735. #define sk_X509_LOOKUP_pop(sk) \

  2736.   ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2737. 

  2738. #define sk_X509_LOOKUP_dup(sk)      \

  2739.   ((STACK_OF(X509_LOOKUP) *)sk_dup( \

  2740.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk)))

  2741. 

  2742. #define sk_X509_LOOKUP_sort(sk) \

  2743.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2744. 

  2745. #define sk_X509_LOOKUP_is_sorted(sk) \

  2746.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk))

  2747. 

  2748. #define sk_X509_LOOKUP_set_cmp_func(sk, comp)                              \

  2749.   ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \

  2750.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk),                 \

  2751.       CHECKED_CAST(stack_cmp_func,                                         \

  2752.                    int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b),  \

  2753.                    comp)))

  2754. 

  2755. #define sk_X509_LOOKUP_deep_copy(sk, copy_func, free_func)             \

  2756.   ((STACK_OF(X509_LOOKUP) *)sk_deep_copy(                              \

  2757.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), \

  2758.       CHECKED_CAST(void *(*)(void *), X509_LOOKUP *(*)(X509_LOOKUP *), \

  2759.                    copy_func),                                         \

  2760.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func)))

  2761. 

  2762. /* X509_NAME */

  2763. #define sk_X509_NAME_new(comp)     \

  2764.   ((STACK_OF(X509_NAME) *)sk_new(  \

  2765.       CHECKED_CAST(stack_cmp_func, \

  2766.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2767. 

  2768. #define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null())

  2769. 

  2770. #define sk_X509_NAME_num(sk) \

  2771.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2772. 

  2773. #define sk_X509_NAME_zero(sk) \

  2774.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));

  2775. 

  2776. #define sk_X509_NAME_value(sk, i) \

  2777.   ((X509_NAME *)sk_value(         \

  2778.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk), (i)))

  2779. 

  2780. #define sk_X509_NAME_set(sk, i, p)                                             \

  2781.   ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \

  2782.                        CHECKED_CAST(void *, X509_NAME *, p)))

  2783. 

  2784. #define sk_X509_NAME_free(sk) \

  2785.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2786. 

  2787. #define sk_X509_NAME_pop_free(sk, free_func)             \

  2788.   sk_pop_free(                                           \

  2789.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2790.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))

  2791. 

  2792. #define sk_X509_NAME_insert(sk, p, where)                      \

  2793.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2794.             CHECKED_CAST(void *, X509_NAME *, p), (where))

  2795. 

  2796. #define sk_X509_NAME_delete(sk, where)                                       \

  2797.   ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2798.                           (where)))

  2799. 

  2800. #define sk_X509_NAME_delete_ptr(sk, p)                   \

  2801.   ((X509_NAME *)sk_delete_ptr(                           \

  2802.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2803.       CHECKED_CAST(void *, X509_NAME *, p)))

  2804. 

  2805. #define sk_X509_NAME_find(sk, out_index, p)                               \

  2806.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \

  2807.           CHECKED_CAST(void *, X509_NAME *, p))

  2808. 

  2809. #define sk_X509_NAME_shift(sk) \

  2810.   ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2811. 

  2812. #define sk_X509_NAME_push(sk, p)                             \

  2813.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2814.           CHECKED_CAST(void *, X509_NAME *, p))

  2815. 

  2816. #define sk_X509_NAME_pop(sk) \

  2817.   ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2818. 

  2819. #define sk_X509_NAME_dup(sk)      \

  2820.   ((STACK_OF(X509_NAME) *)sk_dup( \

  2821.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk)))

  2822. 

  2823. #define sk_X509_NAME_sort(sk) \

  2824.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2825. 

  2826. #define sk_X509_NAME_is_sorted(sk) \

  2827.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk))

  2828. 

  2829. #define sk_X509_NAME_set_cmp_func(sk, comp)                            \

  2830.   ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \

  2831.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk),               \

  2832.       CHECKED_CAST(stack_cmp_func,                                     \

  2833.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2834. 

  2835. #define sk_X509_NAME_deep_copy(sk, copy_func, free_func)                       \

  2836.   ((STACK_OF(X509_NAME) *)sk_deep_copy(                                        \

  2837.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk),           \

  2838.       CHECKED_CAST(void *(*)(void *), X509_NAME *(*)(X509_NAME *), copy_func), \

  2839.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func)))

  2840. 

  2841. /* X509_NAME_ENTRY */

  2842. #define sk_X509_NAME_ENTRY_new(comp)                 \

  2843.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \

  2844.       stack_cmp_func,                                \

  2845.       int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))

  2846. 

  2847. #define sk_X509_NAME_ENTRY_new_null() \

  2848.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())

  2849. 

  2850. #define sk_X509_NAME_ENTRY_num(sk) \

  2851.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2852. 

  2853. #define sk_X509_NAME_ENTRY_zero(sk) \

  2854.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));

  2855. 

  2856. #define sk_X509_NAME_ENTRY_value(sk, i) \

  2857.   ((X509_NAME_ENTRY *)sk_value(         \

  2858.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), (i)))

  2859. 

  2860. #define sk_X509_NAME_ENTRY_set(sk, i, p)                            \

  2861.   ((X509_NAME_ENTRY *)sk_set(                                       \

  2862.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \

  2863.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  2864. 

  2865. #define sk_X509_NAME_ENTRY_free(sk) \

  2866.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2867. 

  2868. #define sk_X509_NAME_ENTRY_pop_free(sk, free_func)             \

  2869.   sk_pop_free(                                                 \

  2870.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2871.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))

  2872. 

  2873. #define sk_X509_NAME_ENTRY_insert(sk, p, where)                      \

  2874.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2875.             CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))

  2876. 

  2877. #define sk_X509_NAME_ENTRY_delete(sk, where) \

  2878.   ((X509_NAME_ENTRY *)sk_delete(             \

  2879.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))

  2880. 

  2881. #define sk_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  2882.   ((X509_NAME_ENTRY *)sk_delete_ptr(                           \

  2883.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2884.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  2885. 

  2886. #define sk_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  2887.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2888.           (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  2889. 

  2890. #define sk_X509_NAME_ENTRY_shift(sk) \

  2891.   ((X509_NAME_ENTRY *)sk_shift(      \

  2892.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  2893. 

  2894. #define sk_X509_NAME_ENTRY_push(sk, p)                             \

  2895.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2896.           CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  2897. 

  2898. #define sk_X509_NAME_ENTRY_pop(sk) \

  2899.   ((X509_NAME_ENTRY *)sk_pop(      \

  2900.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  2901. 

  2902. #define sk_X509_NAME_ENTRY_dup(sk)      \

  2903.   ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \

  2904.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))

  2905. 

  2906. #define sk_X509_NAME_ENTRY_sort(sk) \

  2907.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2908. 

  2909. #define sk_X509_NAME_ENTRY_is_sorted(sk) \

  2910.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

  2911. 

  2912. #define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp)                           \

  2913.   ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b))          \

  2914.        sk_set_cmp_func(                                                     \

  2915.            CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk),         \

  2916.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a,  \

  2917.                                                 const X509_NAME_ENTRY **b), \

  2918.                         comp)))

  2919. 

  2920. #define sk_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)                 \

  2921.   ((STACK_OF(X509_NAME_ENTRY) *)sk_deep_copy(                                  \

  2922.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk),     \

  2923.       CHECKED_CAST(void *(*)(void *), X509_NAME_ENTRY *(*)(X509_NAME_ENTRY *), \

  2924.                    copy_func),                                                 \

  2925.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func)))

  2926. 

  2927. /* X509_OBJECT */

  2928. #define sk_X509_OBJECT_new(comp)                                             \

  2929.   ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST(                             \

  2930.       stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \

  2931.       comp)))

  2932. 

  2933. #define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null())

  2934. 

  2935. #define sk_X509_OBJECT_num(sk) \

  2936.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2937. 

  2938. #define sk_X509_OBJECT_zero(sk) \

  2939.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));

  2940. 

  2941. #define sk_X509_OBJECT_value(sk, i) \

  2942.   ((X509_OBJECT *)sk_value(         \

  2943.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))

  2944. 

  2945. #define sk_X509_OBJECT_set(sk, i, p)                                          \

  2946.   ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2947.                          (i), CHECKED_CAST(void *, X509_OBJECT *, p)))

  2948. 

  2949. #define sk_X509_OBJECT_free(sk) \

  2950.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2951. 

  2952. #define sk_X509_OBJECT_pop_free(sk, free_func)             \

  2953.   sk_pop_free(                                             \

  2954.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2955.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))

  2956. 

  2957. #define sk_X509_OBJECT_insert(sk, p, where)                      \

  2958.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2959.             CHECKED_CAST(void *, X509_OBJECT *, p), (where))

  2960. 

  2961. #define sk_X509_OBJECT_delete(sk, where) \

  2962.   ((X509_OBJECT *)sk_delete(             \

  2963.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))

  2964. 

  2965. #define sk_X509_OBJECT_delete_ptr(sk, p)                   \

  2966.   ((X509_OBJECT *)sk_delete_ptr(                           \

  2967.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2968.       CHECKED_CAST(void *, X509_OBJECT *, p)))

  2969. 

  2970. #define sk_X509_OBJECT_find(sk, out_index, p)                               \

  2971.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \

  2972.           CHECKED_CAST(void *, X509_OBJECT *, p))

  2973. 

  2974. #define sk_X509_OBJECT_shift(sk) \

  2975.   ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  2976. 

  2977. #define sk_X509_OBJECT_push(sk, p)                             \

  2978.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2979.           CHECKED_CAST(void *, X509_OBJECT *, p))

  2980. 

  2981. #define sk_X509_OBJECT_pop(sk) \

  2982.   ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  2983. 

  2984. #define sk_X509_OBJECT_dup(sk)      \

  2985.   ((STACK_OF(X509_OBJECT) *)sk_dup( \

  2986.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk)))

  2987. 

  2988. #define sk_X509_OBJECT_sort(sk) \

  2989.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2990. 

  2991. #define sk_X509_OBJECT_is_sorted(sk) \

  2992.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk))

  2993. 

  2994. #define sk_X509_OBJECT_set_cmp_func(sk, comp)                              \

  2995.   ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \

  2996.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk),                 \

  2997.       CHECKED_CAST(stack_cmp_func,                                         \

  2998.                    int (*)(const X509_OBJECT **a, const X509_OBJECT **b),  \

  2999.                    comp)))

  3000. 

  3001. #define sk_X509_OBJECT_deep_copy(sk, copy_func, free_func)             \

  3002.   ((STACK_OF(X509_OBJECT) *)sk_deep_copy(                              \

  3003.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), \

  3004.       CHECKED_CAST(void *(*)(void *), X509_OBJECT *(*)(X509_OBJECT *), \

  3005.                    copy_func),                                         \

  3006.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func)))

  3007. 

  3008. /* X509_POLICY_DATA */

  3009. #define sk_X509_POLICY_DATA_new(comp)                 \

  3010.   ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \

  3011.       stack_cmp_func,                                 \

  3012.       int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))

  3013. 

  3014. #define sk_X509_POLICY_DATA_new_null() \

  3015.   ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())

  3016. 

  3017. #define sk_X509_POLICY_DATA_num(sk) \

  3018.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3019. 

  3020. #define sk_X509_POLICY_DATA_zero(sk) \

  3021.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));

  3022. 

  3023. #define sk_X509_POLICY_DATA_value(sk, i) \

  3024.   ((X509_POLICY_DATA *)sk_value(         \

  3025.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), (i)))

  3026. 

  3027. #define sk_X509_POLICY_DATA_set(sk, i, p)                            \

  3028.   ((X509_POLICY_DATA *)sk_set(                                       \

  3029.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \

  3030.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3031. 

  3032. #define sk_X509_POLICY_DATA_free(sk) \

  3033.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3034. 

  3035. #define sk_X509_POLICY_DATA_pop_free(sk, free_func)             \

  3036.   sk_pop_free(                                                  \

  3037.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3038.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))

  3039. 

  3040. #define sk_X509_POLICY_DATA_insert(sk, p, where)                      \

  3041.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3042.             CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))

  3043. 

  3044. #define sk_X509_POLICY_DATA_delete(sk, where) \

  3045.   ((X509_POLICY_DATA *)sk_delete(             \

  3046.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))

  3047. 

  3048. #define sk_X509_POLICY_DATA_delete_ptr(sk, p)                   \

  3049.   ((X509_POLICY_DATA *)sk_delete_ptr(                           \

  3050.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3051.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3052. 

  3053. #define sk_X509_POLICY_DATA_find(sk, out_index, p)                  \

  3054.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3055.           (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3056. 

  3057. #define sk_X509_POLICY_DATA_shift(sk) \

  3058.   ((X509_POLICY_DATA *)sk_shift(      \

  3059.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3060. 

  3061. #define sk_X509_POLICY_DATA_push(sk, p)                             \

  3062.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3063.           CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3064. 

  3065. #define sk_X509_POLICY_DATA_pop(sk) \

  3066.   ((X509_POLICY_DATA *)sk_pop(      \

  3067.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3068. 

  3069. #define sk_X509_POLICY_DATA_dup(sk)      \

  3070.   ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \

  3071.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))

  3072. 

  3073. #define sk_X509_POLICY_DATA_sort(sk) \

  3074.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3075. 

  3076. #define sk_X509_POLICY_DATA_is_sorted(sk) \

  3077.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

  3078. 

  3079. #define sk_X509_POLICY_DATA_set_cmp_func(sk, comp)                           \

  3080.   ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b))         \

  3081.        sk_set_cmp_func(                                                      \

  3082.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk),         \

  3083.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a,  \

  3084.                                                 const X509_POLICY_DATA **b), \

  3085.                         comp)))

  3086. 

  3087. #define sk_X509_POLICY_DATA_deep_copy(sk, copy_func, free_func)             \

  3088.   ((STACK_OF(X509_POLICY_DATA) *)sk_deep_copy(                              \

  3089.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \

  3090.       CHECKED_CAST(void *(*)(void *),                                       \

  3091.                    X509_POLICY_DATA *(*)(X509_POLICY_DATA *), copy_func),   \

  3092.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *),          \

  3093.                    free_func)))

  3094. 

  3095. /* X509_POLICY_NODE */

  3096. #define sk_X509_POLICY_NODE_new(comp)                 \

  3097.   ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \

  3098.       stack_cmp_func,                                 \

  3099.       int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))

  3100. 

  3101. #define sk_X509_POLICY_NODE_new_null() \

  3102.   ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())

  3103. 

  3104. #define sk_X509_POLICY_NODE_num(sk) \

  3105.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3106. 

  3107. #define sk_X509_POLICY_NODE_zero(sk) \

  3108.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));

  3109. 

  3110. #define sk_X509_POLICY_NODE_value(sk, i) \

  3111.   ((X509_POLICY_NODE *)sk_value(         \

  3112.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), (i)))

  3113. 

  3114. #define sk_X509_POLICY_NODE_set(sk, i, p)                            \

  3115.   ((X509_POLICY_NODE *)sk_set(                                       \

  3116.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \

  3117.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3118. 

  3119. #define sk_X509_POLICY_NODE_free(sk) \

  3120.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3121. 

  3122. #define sk_X509_POLICY_NODE_pop_free(sk, free_func)             \

  3123.   sk_pop_free(                                                  \

  3124.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3125.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))

  3126. 

  3127. #define sk_X509_POLICY_NODE_insert(sk, p, where)                      \

  3128.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3129.             CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))

  3130. 

  3131. #define sk_X509_POLICY_NODE_delete(sk, where) \

  3132.   ((X509_POLICY_NODE *)sk_delete(             \

  3133.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))

  3134. 

  3135. #define sk_X509_POLICY_NODE_delete_ptr(sk, p)                   \

  3136.   ((X509_POLICY_NODE *)sk_delete_ptr(                           \

  3137.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3138.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3139. 

  3140. #define sk_X509_POLICY_NODE_find(sk, out_index, p)                  \

  3141.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3142.           (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3143. 

  3144. #define sk_X509_POLICY_NODE_shift(sk) \

  3145.   ((X509_POLICY_NODE *)sk_shift(      \

  3146.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3147. 

  3148. #define sk_X509_POLICY_NODE_push(sk, p)                             \

  3149.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3150.           CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3151. 

  3152. #define sk_X509_POLICY_NODE_pop(sk) \

  3153.   ((X509_POLICY_NODE *)sk_pop(      \

  3154.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3155. 

  3156. #define sk_X509_POLICY_NODE_dup(sk)      \

  3157.   ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \

  3158.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))

  3159. 

  3160. #define sk_X509_POLICY_NODE_sort(sk) \

  3161.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3162. 

  3163. #define sk_X509_POLICY_NODE_is_sorted(sk) \

  3164.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

  3165. 

  3166. #define sk_X509_POLICY_NODE_set_cmp_func(sk, comp)                           \

  3167.   ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b))         \

  3168.        sk_set_cmp_func(                                                      \

  3169.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk),         \

  3170.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a,  \

  3171.                                                 const X509_POLICY_NODE **b), \

  3172.                         comp)))

  3173. 

  3174. #define sk_X509_POLICY_NODE_deep_copy(sk, copy_func, free_func)             \

  3175.   ((STACK_OF(X509_POLICY_NODE) *)sk_deep_copy(                              \

  3176.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \

  3177.       CHECKED_CAST(void *(*)(void *),                                       \

  3178.                    X509_POLICY_NODE *(*)(X509_POLICY_NODE *), copy_func),   \

  3179.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *),          \

  3180.                    free_func)))

  3181. 

  3182. /* X509_PURPOSE */

  3183. #define sk_X509_PURPOSE_new(comp)                                              \

  3184.   ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST(                              \

  3185.       stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \

  3186.       comp)))

  3187. 

  3188. #define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null())

  3189. 

  3190. #define sk_X509_PURPOSE_num(sk) \

  3191.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3192. 

  3193. #define sk_X509_PURPOSE_zero(sk) \

  3194.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));

  3195. 

  3196. #define sk_X509_PURPOSE_value(sk, i) \

  3197.   ((X509_PURPOSE *)sk_value(         \

  3198.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))

  3199. 

  3200. #define sk_X509_PURPOSE_set(sk, i, p)                            \

  3201.   ((X509_PURPOSE *)sk_set(                                       \

  3202.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \

  3203.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3204. 

  3205. #define sk_X509_PURPOSE_free(sk) \

  3206.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3207. 

  3208. #define sk_X509_PURPOSE_pop_free(sk, free_func)             \

  3209.   sk_pop_free(                                              \

  3210.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3211.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))

  3212. 

  3213. #define sk_X509_PURPOSE_insert(sk, p, where)                      \

  3214.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3215.             CHECKED_CAST(void *, X509_PURPOSE *, p), (where))

  3216. 

  3217. #define sk_X509_PURPOSE_delete(sk, where) \

  3218.   ((X509_PURPOSE *)sk_delete(             \

  3219.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))

  3220. 

  3221. #define sk_X509_PURPOSE_delete_ptr(sk, p)                   \

  3222.   ((X509_PURPOSE *)sk_delete_ptr(                           \

  3223.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3224.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3225. 

  3226. #define sk_X509_PURPOSE_find(sk, out_index, p)                               \

  3227.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \

  3228.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3229. 

  3230. #define sk_X509_PURPOSE_shift(sk) \

  3231.   ((X509_PURPOSE *)sk_shift(      \

  3232.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3233. 

  3234. #define sk_X509_PURPOSE_push(sk, p)                             \

  3235.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3236.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3237. 

  3238. #define sk_X509_PURPOSE_pop(sk) \

  3239.   ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3240. 

  3241. #define sk_X509_PURPOSE_dup(sk)      \

  3242.   ((STACK_OF(X509_PURPOSE) *)sk_dup( \

  3243.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk)))

  3244. 

  3245. #define sk_X509_PURPOSE_sort(sk) \

  3246.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3247. 

  3248. #define sk_X509_PURPOSE_is_sorted(sk) \

  3249.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk))

  3250. 

  3251. #define sk_X509_PURPOSE_set_cmp_func(sk, comp)                               \

  3252.   ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \

  3253.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk),                  \

  3254.       CHECKED_CAST(stack_cmp_func,                                           \

  3255.                    int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b),  \

  3256.                    comp)))

  3257. 

  3258. #define sk_X509_PURPOSE_deep_copy(sk, copy_func, free_func)              \

  3259.   ((STACK_OF(X509_PURPOSE) *)sk_deep_copy(                               \

  3260.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk),  \

  3261.       CHECKED_CAST(void *(*)(void *), X509_PURPOSE *(*)(X509_PURPOSE *), \

  3262.                    copy_func),                                           \

  3263.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func)))

  3264. 

  3265. /* X509_REVOKED */

  3266. #define sk_X509_REVOKED_new(comp)                                              \

  3267.   ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST(                              \

  3268.       stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \

  3269.       comp)))

  3270. 

  3271. #define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null())

  3272. 

  3273. #define sk_X509_REVOKED_num(sk) \

  3274.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3275. 

  3276. #define sk_X509_REVOKED_zero(sk) \

  3277.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));

  3278. 

  3279. #define sk_X509_REVOKED_value(sk, i) \

  3280.   ((X509_REVOKED *)sk_value(         \

  3281.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))

  3282. 

  3283. #define sk_X509_REVOKED_set(sk, i, p)                            \

  3284.   ((X509_REVOKED *)sk_set(                                       \

  3285.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \

  3286.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3287. 

  3288. #define sk_X509_REVOKED_free(sk) \

  3289.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3290. 

  3291. #define sk_X509_REVOKED_pop_free(sk, free_func)             \

  3292.   sk_pop_free(                                              \

  3293.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3294.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))

  3295. 

  3296. #define sk_X509_REVOKED_insert(sk, p, where)                      \

  3297.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3298.             CHECKED_CAST(void *, X509_REVOKED *, p), (where))

  3299. 

  3300. #define sk_X509_REVOKED_delete(sk, where) \

  3301.   ((X509_REVOKED *)sk_delete(             \

  3302.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))

  3303. 

  3304. #define sk_X509_REVOKED_delete_ptr(sk, p)                   \

  3305.   ((X509_REVOKED *)sk_delete_ptr(                           \

  3306.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3307.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3308. 

  3309. #define sk_X509_REVOKED_find(sk, out_index, p)                               \

  3310.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \

  3311.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3312. 

  3313. #define sk_X509_REVOKED_shift(sk) \

  3314.   ((X509_REVOKED *)sk_shift(      \

  3315.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3316. 

  3317. #define sk_X509_REVOKED_push(sk, p)                             \

  3318.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3319.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3320. 

  3321. #define sk_X509_REVOKED_pop(sk) \

  3322.   ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3323. 

  3324. #define sk_X509_REVOKED_dup(sk)      \

  3325.   ((STACK_OF(X509_REVOKED) *)sk_dup( \

  3326.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk)))

  3327. 

  3328. #define sk_X509_REVOKED_sort(sk) \

  3329.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3330. 

  3331. #define sk_X509_REVOKED_is_sorted(sk) \

  3332.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk))

  3333. 

  3334. #define sk_X509_REVOKED_set_cmp_func(sk, comp)                               \

  3335.   ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \

  3336.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk),                  \

  3337.       CHECKED_CAST(stack_cmp_func,                                           \

  3338.                    int (*)(const X509_REVOKED **a, const X509_REVOKED **b),  \

  3339.                    comp)))

  3340. 

  3341. #define sk_X509_REVOKED_deep_copy(sk, copy_func, free_func)              \

  3342.   ((STACK_OF(X509_REVOKED) *)sk_deep_copy(                               \

  3343.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk),  \

  3344.       CHECKED_CAST(void *(*)(void *), X509_REVOKED *(*)(X509_REVOKED *), \

  3345.                    copy_func),                                           \

  3346.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func)))

  3347. 

  3348. /* X509_TRUST */

  3349. #define sk_X509_TRUST_new(comp)                                            \

  3350.   ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST(                            \

  3351.       stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \

  3352.       comp)))

  3353. 

  3354. #define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null())

  3355. 

  3356. #define sk_X509_TRUST_num(sk) \

  3357.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3358. 

  3359. #define sk_X509_TRUST_zero(sk) \

  3360.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));

  3361. 

  3362. #define sk_X509_TRUST_value(sk, i) \

  3363.   ((X509_TRUST *)sk_value(         \

  3364.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))

  3365. 

  3366. #define sk_X509_TRUST_set(sk, i, p)                                         \

  3367.   ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3368.                         (i), CHECKED_CAST(void *, X509_TRUST *, p)))

  3369. 

  3370. #define sk_X509_TRUST_free(sk) \

  3371.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3372. 

  3373. #define sk_X509_TRUST_pop_free(sk, free_func)             \

  3374.   sk_pop_free(                                            \

  3375.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3376.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))

  3377. 

  3378. #define sk_X509_TRUST_insert(sk, p, where)                      \

  3379.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3380.             CHECKED_CAST(void *, X509_TRUST *, p), (where))

  3381. 

  3382. #define sk_X509_TRUST_delete(sk, where)                                        \

  3383.   ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3384.                            (where)))

  3385. 

  3386. #define sk_X509_TRUST_delete_ptr(sk, p)                   \

  3387.   ((X509_TRUST *)sk_delete_ptr(                           \

  3388.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3389.       CHECKED_CAST(void *, X509_TRUST *, p)))

  3390. 

  3391. #define sk_X509_TRUST_find(sk, out_index, p)                               \

  3392.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \

  3393.           CHECKED_CAST(void *, X509_TRUST *, p))

  3394. 

  3395. #define sk_X509_TRUST_shift(sk) \

  3396.   ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3397. 

  3398. #define sk_X509_TRUST_push(sk, p)                             \

  3399.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3400.           CHECKED_CAST(void *, X509_TRUST *, p))

  3401. 

  3402. #define sk_X509_TRUST_pop(sk) \

  3403.   ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3404. 

  3405. #define sk_X509_TRUST_dup(sk)      \

  3406.   ((STACK_OF(X509_TRUST) *)sk_dup( \

  3407.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk)))

  3408. 

  3409. #define sk_X509_TRUST_sort(sk) \

  3410.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3411. 

  3412. #define sk_X509_TRUST_is_sorted(sk) \

  3413.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk))

  3414. 

  3415. #define sk_X509_TRUST_set_cmp_func(sk, comp)                             \

  3416.   ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \

  3417.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk),                \

  3418.       CHECKED_CAST(stack_cmp_func,                                       \

  3419.                    int (*)(const X509_TRUST **a, const X509_TRUST **b),  \

  3420.                    comp)))

  3421. 

  3422. #define sk_X509_TRUST_deep_copy(sk, copy_func, free_func)             \

  3423.   ((STACK_OF(X509_TRUST) *)sk_deep_copy(                              \

  3424.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), \

  3425.       CHECKED_CAST(void *(*)(void *), X509_TRUST *(*)(X509_TRUST *),  \

  3426.                    copy_func),                                        \

  3427.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func)))

  3428. 

  3429. /* X509_VERIFY_PARAM */

  3430. #define sk_X509_VERIFY_PARAM_new(comp)                                   \

  3431.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST(                   \

  3432.       stack_cmp_func,                                                    \

  3433.       int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \

  3434.       comp)))

  3435. 

  3436. #define sk_X509_VERIFY_PARAM_new_null() \

  3437.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())

  3438. 

  3439. #define sk_X509_VERIFY_PARAM_num(sk) \

  3440.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3441. 

  3442. #define sk_X509_VERIFY_PARAM_zero(sk) \

  3443.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));

  3444. 

  3445. #define sk_X509_VERIFY_PARAM_value(sk, i) \

  3446.   ((X509_VERIFY_PARAM *)sk_value(         \

  3447.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), (i)))

  3448. 

  3449. #define sk_X509_VERIFY_PARAM_set(sk, i, p)                            \

  3450.   ((X509_VERIFY_PARAM *)sk_set(                                       \

  3451.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \

  3452.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3453. 

  3454. #define sk_X509_VERIFY_PARAM_free(sk) \

  3455.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3456. 

  3457. #define sk_X509_VERIFY_PARAM_pop_free(sk, free_func)                        \

  3458.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),    \

  3459.               CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \

  3460.                            free_func))

  3461. 

  3462. #define sk_X509_VERIFY_PARAM_insert(sk, p, where)                      \

  3463.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3464.             CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))

  3465. 

  3466. #define sk_X509_VERIFY_PARAM_delete(sk, where) \

  3467.   ((X509_VERIFY_PARAM *)sk_delete(             \

  3468.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))

  3469. 

  3470. #define sk_X509_VERIFY_PARAM_delete_ptr(sk, p)                   \

  3471.   ((X509_VERIFY_PARAM *)sk_delete_ptr(                           \

  3472.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3473.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3474. 

  3475. #define sk_X509_VERIFY_PARAM_find(sk, out_index, p)                  \

  3476.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3477.           (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3478. 

  3479. #define sk_X509_VERIFY_PARAM_shift(sk) \

  3480.   ((X509_VERIFY_PARAM *)sk_shift(      \

  3481.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3482. 

  3483. #define sk_X509_VERIFY_PARAM_push(sk, p)                             \

  3484.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3485.           CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3486. 

  3487. #define sk_X509_VERIFY_PARAM_pop(sk) \

  3488.   ((X509_VERIFY_PARAM *)sk_pop(      \

  3489.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3490. 

  3491. #define sk_X509_VERIFY_PARAM_dup(sk)      \

  3492.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \

  3493.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3494. 

  3495. #define sk_X509_VERIFY_PARAM_sort(sk) \

  3496.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3497. 

  3498. #define sk_X509_VERIFY_PARAM_is_sorted(sk) \

  3499.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

  3500. 

  3501. #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp)                           \

  3502.   ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b))        \

  3503.        sk_set_cmp_func(                                                       \

  3504.            CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),         \

  3505.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a,  \

  3506.                                                 const X509_VERIFY_PARAM **b), \

  3507.                         comp)))

  3508. 

  3509. #define sk_X509_VERIFY_PARAM_deep_copy(sk, copy_func, free_func)             \

  3510.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_deep_copy(                              \

  3511.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3512.       CHECKED_CAST(void *(*)(void *),                                        \

  3513.                    X509_VERIFY_PARAM *(*)(X509_VERIFY_PARAM *), copy_func),  \

  3514.       CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *),          \

  3515.                    free_func)))

  3516. 

  3517. /* void */

  3518. #define sk_void_new(comp)                \

  3519.   ((STACK_OF(void)*)sk_new(CHECKED_CAST( \

  3520.       stack_cmp_func, int (*)(const void **a, const void **b), comp)))

  3521. 

  3522. #define sk_void_new_null() ((STACK_OF(void)*)sk_new_null())

  3523. 

  3524. #define sk_void_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3525. 

  3526. #define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk));

  3527. 

  3528. #define sk_void_value(sk, i) \

  3529.   ((void *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk), (i)))

  3530. 

  3531. #define sk_void_set(sk, i, p)                                       \

  3532.   ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (i), \

  3533.                   CHECKED_CAST(void *, void *, p)))

  3534. 

  3535. #define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3536. 

  3537. #define sk_void_pop_free(sk, free_func)                     \

  3538.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3539.               CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))

  3540. 

  3541. #define sk_void_insert(sk, p, where)                      \

  3542.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3543.             CHECKED_CAST(void *, void *, p), (where))

  3544. 

  3545. #define sk_void_delete(sk, where) \

  3546.   ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (where)))

  3547. 

  3548. #define sk_void_delete_ptr(sk, p)                                     \

  3549.   ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3550.                          CHECKED_CAST(void *, void *, p)))

  3551. 

  3552. #define sk_void_find(sk, out_index, p)                               \

  3553.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (out_index), \

  3554.           CHECKED_CAST(void *, void *, p))

  3555. 

  3556. #define sk_void_shift(sk) \

  3557.   ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3558. 

  3559. #define sk_void_push(sk, p)                             \

  3560.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3561.           CHECKED_CAST(void *, void *, p))

  3562. 

  3563. #define sk_void_pop(sk) \

  3564.   ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3565. 

  3566. #define sk_void_dup(sk) \

  3567.   ((STACK_OF(void)*)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk)))

  3568. 

  3569. #define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3570. 

  3571. #define sk_void_is_sorted(sk) \

  3572.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk))

  3573. 

  3574. #define sk_void_set_cmp_func(sk, comp)                                      \

  3575.   ((int (*)(const void **a, const void **b))sk_set_cmp_func(                \

  3576.       CHECKED_CAST(_STACK *, STACK_OF(void)*, sk),                          \

  3577.       CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \

  3578.                    comp)))

  3579. 

  3580. #define sk_void_deep_copy(sk, copy_func, free_func)                  \

  3581.   ((STACK_OF(void)*)sk_deep_copy(                                    \

  3582.       CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk),      \

  3583.       CHECKED_CAST(void *(*)(void *), void *(*)(void *), copy_func), \

  3584.       CHECKED_CAST(void (*)(void *), void (*)(void *), free_func)))

  3585. 

  3586. /* SRTP_PROTECTION_PROFILE */

  3587. #define sk_SRTP_PROTECTION_PROFILE_new(comp)                            \

  3588.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST(            \

  3589.       stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a,  \

  3590.                               const const SRTP_PROTECTION_PROFILE **b), \

  3591.       comp)))

  3592. 

  3593. #define sk_SRTP_PROTECTION_PROFILE_new_null() \

  3594.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())

  3595. 

  3596. #define sk_SRTP_PROTECTION_PROFILE_num(sk) \

  3597.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3598. 

  3599. #define sk_SRTP_PROTECTION_PROFILE_zero(sk) \

  3600.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));

  3601. 

  3602. #define sk_SRTP_PROTECTION_PROFILE_value(sk, i)                              \

  3603.   ((const SRTP_PROTECTION_PROFILE *)sk_value(                                \

  3604.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3605.       (i)))

  3606. 

  3607. #define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p)                            \

  3608.   ((const SRTP_PROTECTION_PROFILE *)sk_set(                                 \

  3609.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \

  3610.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3611. 

  3612. #define sk_SRTP_PROTECTION_PROFILE_free(sk) \

  3613.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3614. 

  3615. #define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func)             \

  3616.   sk_pop_free(                                                         \

  3617.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3618.       CHECKED_CAST(void (*)(void *),                                   \

  3619.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func))

  3620. 

  3621. #define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where)                      \

  3622.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3623.             CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where))

  3624. 

  3625. #define sk_SRTP_PROTECTION_PROFILE_delete(sk, where)                   \

  3626.   ((const SRTP_PROTECTION_PROFILE *)sk_delete(                         \

  3627.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3628.       (where)))

  3629. 

  3630. #define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p)                   \

  3631.   ((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr(                     \

  3632.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3633.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3634. 

  3635. #define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p)                  \

  3636.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3637.           (out_index),                                                     \

  3638.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3639. 

  3640. #define sk_SRTP_PROTECTION_PROFILE_shift(sk)  \

  3641.   ((const SRTP_PROTECTION_PROFILE *)sk_shift( \

  3642.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3643. 

  3644. #define sk_SRTP_PROTECTION_PROFILE_push(sk, p)                             \

  3645.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3646.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3647. 

  3648. #define sk_SRTP_PROTECTION_PROFILE_pop(sk)  \

  3649.   ((const SRTP_PROTECTION_PROFILE *)sk_pop( \

  3650.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3651. 

  3652. #define sk_SRTP_PROTECTION_PROFILE_dup(sk)      \

  3653.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup( \

  3654.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3655. 

  3656. #define sk_SRTP_PROTECTION_PROFILE_sort(sk) \

  3657.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3658. 

  3659. #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \

  3660.   sk_is_sorted(                                  \

  3661.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3662. 

  3663. #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp)                   \

  3664.   ((int (*)(const SRTP_PROTECTION_PROFILE **a,                              \

  3665.             const SRTP_PROTECTION_PROFILE **b))                             \

  3666.        sk_set_cmp_func(                                                     \

  3667.            CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3668.            CHECKED_CAST(stack_cmp_func,                                     \

  3669.                         int (*)(const SRTP_PROTECTION_PROFILE **a,          \

  3670.                                 const SRTP_PROTECTION_PROFILE **b),         \

  3671.                         comp)))

  3672. 

  3673. #define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copy_func, free_func)        \

  3674.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_deep_copy(                         \

  3675.       CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \

  3676.                    sk),                                                       \

  3677.       CHECKED_CAST(void *(*)(void *), const SRTP_PROTECTION_PROFILE *(*)(     \

  3678.                                           const SRTP_PROTECTION_PROFILE *),   \

  3679.                    copy_func),                                                \

  3680.       CHECKED_CAST(void (*)(void *),                                          \

  3681.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func)))

  3682. 

  3683. /* SSL_CIPHER */

  3684. #define sk_SSL_CIPHER_new(comp)                 \

  3685.   ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \

  3686.       stack_cmp_func,                           \

  3687.       int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp)))

  3688. 

  3689. #define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null())

  3690. 

  3691. #define sk_SSL_CIPHER_num(sk) \

  3692.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3693. 

  3694. #define sk_SSL_CIPHER_zero(sk) \

  3695.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));

  3696. 

  3697. #define sk_SSL_CIPHER_value(sk, i) \

  3698.   ((const SSL_CIPHER *)sk_value(   \

  3699.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))

  3700. 

  3701. #define sk_SSL_CIPHER_set(sk, i, p)                            \

  3702.   ((const SSL_CIPHER *)sk_set(                                 \

  3703.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \

  3704.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3705. 

  3706. #define sk_SSL_CIPHER_free(sk) \

  3707.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3708. 

  3709. #define sk_SSL_CIPHER_pop_free(sk, free_func)             \

  3710.   sk_pop_free(                                            \

  3711.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3712.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func))

  3713. 

  3714. #define sk_SSL_CIPHER_insert(sk, p, where)                      \

  3715.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3716.             CHECKED_CAST(void *, const SSL_CIPHER *, p), (where))

  3717. 

  3718. #define sk_SSL_CIPHER_delete(sk, where) \

  3719.   ((const SSL_CIPHER *)sk_delete(       \

  3720.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where)))

  3721. 

  3722. #define sk_SSL_CIPHER_delete_ptr(sk, p)                   \

  3723.   ((const SSL_CIPHER *)sk_delete_ptr(                     \

  3724.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3725.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3726. 

  3727. #define sk_SSL_CIPHER_find(sk, out_index, p)                               \

  3728.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \

  3729.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3730. 

  3731. #define sk_SSL_CIPHER_shift(sk)  \

  3732.   ((const SSL_CIPHER *)sk_shift( \

  3733.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3734. 

  3735. #define sk_SSL_CIPHER_push(sk, p)                             \

  3736.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3737.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3738. 

  3739. #define sk_SSL_CIPHER_pop(sk)  \

  3740.   ((const SSL_CIPHER *)sk_pop( \

  3741.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3742. 

  3743. #define sk_SSL_CIPHER_dup(sk)      \

  3744.   ((STACK_OF(SSL_CIPHER) *)sk_dup( \

  3745.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk)))

  3746. 

  3747. #define sk_SSL_CIPHER_sort(sk) \

  3748.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3749. 

  3750. #define sk_SSL_CIPHER_is_sorted(sk) \

  3751.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk))

  3752. 

  3753. #define sk_SSL_CIPHER_set_cmp_func(sk, comp)                             \

  3754.   ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \

  3755.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk),                \

  3756.       CHECKED_CAST(stack_cmp_func,                                       \

  3757.                    int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b),  \

  3758.                    comp)))

  3759. 

  3760. #define sk_SSL_CIPHER_deep_copy(sk, copy_func, free_func)                 \

  3761.   ((STACK_OF(SSL_CIPHER) *)sk_deep_copy(                                  \

  3762.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk),     \

  3763.       CHECKED_CAST(void *(*)(void *),                                     \

  3764.                    const SSL_CIPHER *(*)(const SSL_CIPHER *), copy_func), \

  3765.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *),        \

  3766.                    free_func)))

  3767. 

  3768. /* OPENSSL_STRING */

  3769. #define sk_OPENSSL_STRING_new(comp)                 \

  3770.   ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \

  3771.       stack_cmp_func,                               \

  3772.       int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))

  3773. 

  3774. #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())

  3775. 

  3776. #define sk_OPENSSL_STRING_num(sk) \

  3777.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3778. 

  3779. #define sk_OPENSSL_STRING_zero(sk) \

  3780.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));

  3781. 

  3782. #define sk_OPENSSL_STRING_value(sk, i) \

  3783.   ((OPENSSL_STRING)sk_value(           \

  3784.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk), (i)))

  3785. 

  3786. #define sk_OPENSSL_STRING_set(sk, i, p)                            \

  3787.   ((OPENSSL_STRING)sk_set(                                         \

  3788.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \

  3789.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3790. 

  3791. #define sk_OPENSSL_STRING_free(sk) \

  3792.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3793. 

  3794. #define sk_OPENSSL_STRING_pop_free(sk, free_func)             \

  3795.   sk_pop_free(                                                \

  3796.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3797.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))

  3798. 

  3799. #define sk_OPENSSL_STRING_insert(sk, p, where)                      \

  3800.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3801.             CHECKED_CAST(void *, OPENSSL_STRING, p), (where))

  3802. 

  3803. #define sk_OPENSSL_STRING_delete(sk, where) \

  3804.   ((OPENSSL_STRING)sk_delete(               \

  3805.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))

  3806. 

  3807. #define sk_OPENSSL_STRING_delete_ptr(sk, p)                   \

  3808.   ((OPENSSL_STRING)sk_delete_ptr(                             \

  3809.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3810.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3811. 

  3812. #define sk_OPENSSL_STRING_find(sk, out_index, p)                               \

  3813.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \

  3814.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3815. 

  3816. #define sk_OPENSSL_STRING_shift(sk) \

  3817.   ((OPENSSL_STRING)sk_shift(        \

  3818.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3819. 

  3820. #define sk_OPENSSL_STRING_push(sk, p)                             \

  3821.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3822.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3823. 

  3824. #define sk_OPENSSL_STRING_pop(sk) \

  3825.   ((OPENSSL_STRING)sk_pop(        \

  3826.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3827. 

  3828. #define sk_OPENSSL_STRING_dup(sk)      \

  3829.   ((STACK_OF(OPENSSL_STRING) *)sk_dup( \

  3830.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))

  3831. 

  3832. #define sk_OPENSSL_STRING_sort(sk) \

  3833.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3834. 

  3835. #define sk_OPENSSL_STRING_is_sorted(sk) \

  3836.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

  3837. 

  3838. #define sk_OPENSSL_STRING_set_cmp_func(sk, comp)                           \

  3839.   ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b))           \

  3840.        sk_set_cmp_func(                                                    \

  3841.            CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk),         \

  3842.            CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a,  \

  3843.                                                 const OPENSSL_STRING **b), \

  3844.                         comp)))

  3845. 

  3846. #define sk_OPENSSL_STRING_deep_copy(sk, copy_func, free_func)             \

  3847.   ((STACK_OF(OPENSSL_STRING) *)sk_deep_copy(                              \

  3848.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \

  3849.       CHECKED_CAST(void *(*)(void *), OPENSSL_STRING (*)(OPENSSL_STRING), \

  3850.                    copy_func),                                            \

  3851.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func)))

  3852. 

  3853. /* OPENSSL_BLOCK */

  3854. #define sk_OPENSSL_BLOCK_new(comp)                                             \

  3855.   ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_CAST(                             \

  3856.       stack_cmp_func, int (*)(const OPENSSL_BLOCK *a, const OPENSSL_BLOCK *b), \

  3857.       comp)))

  3858. 

  3859. #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())

  3860. 

  3861. #define sk_OPENSSL_BLOCK_num(sk) \

  3862.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3863. 

  3864. #define sk_OPENSSL_BLOCK_zero(sk) \

  3865.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk));

  3866. 

  3867. #define sk_OPENSSL_BLOCK_value(sk, i) \

  3868.   ((OPENSSL_BLOCK)sk_value(           \

  3869.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), (i)))

  3870. 

  3871. #define sk_OPENSSL_BLOCK_set(sk, i, p)                            \

  3872.   ((OPENSSL_BLOCK)sk_set(                                         \

  3873.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (i), \

  3874.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  3875. 

  3876. #define sk_OPENSSL_BLOCK_free(sk) \

  3877.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3878. 

  3879. #define sk_OPENSSL_BLOCK_pop_free(sk, free_func)             \

  3880.   sk_pop_free(                                               \

  3881.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3882.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func))

  3883. 

  3884. #define sk_OPENSSL_BLOCK_insert(sk, p, where)                      \

  3885.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3886.             CHECKED_CAST(void *, OPENSSL_BLOCK, p), (where))

  3887. 

  3888. #define sk_OPENSSL_BLOCK_delete(sk, where) \

  3889.   ((OPENSSL_BLOCK)sk_delete(               \

  3890.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (where)))

  3891. 

  3892. #define sk_OPENSSL_BLOCK_delete_ptr(sk, p)                   \

  3893.   ((OPENSSL_BLOCK)sk_delete_ptr(                             \

  3894.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3895.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  3896. 

  3897. #define sk_OPENSSL_BLOCK_find(sk, out_index, p)                               \

  3898.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (out_index), \

  3899.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  3900. 

  3901. #define sk_OPENSSL_BLOCK_shift(sk) \

  3902.   ((OPENSSL_BLOCK)sk_shift(        \

  3903.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  3904. 

  3905. #define sk_OPENSSL_BLOCK_push(sk, p)                             \

  3906.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3907.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  3908. 

  3909. #define sk_OPENSSL_BLOCK_pop(sk) \

  3910.   ((OPENSSL_BLOCK)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  3911. 

  3912. #define sk_OPENSSL_BLOCK_dup(sk)      \

  3913.   ((STACK_OF(OPENSSL_BLOCK) *)sk_dup( \

  3914.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)))

  3915. 

  3916. #define sk_OPENSSL_BLOCK_sort(sk) \

  3917.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3918. 

  3919. #define sk_OPENSSL_BLOCK_is_sorted(sk) \

  3920.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk))

  3921. 

  3922. #define sk_OPENSSL_BLOCK_set_cmp_func(sk, comp)                                \

  3923.   ((int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b))sk_set_cmp_func( \

  3924.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk),                   \

  3925.       CHECKED_CAST(stack_cmp_func,                                             \

  3926.                    int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b),  \

  3927.                    comp)))

  3928. 

  3929. #define sk_OPENSSL_BLOCK_deep_copy(sk, copy_func, free_func)             \

  3930.   ((STACK_OF(OPENSSL_BLOCK) *)sk_deep_copy(                              \

  3931.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), \

  3932.       CHECKED_CAST(void *(*)(void *), OPENSSL_BLOCK (*)(OPENSSL_BLOCK),  \

  3933.                    copy_func),                                           \

  3934.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func)))