kris
/
boringssl
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
2080 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tree: a0ef7b0a56
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a0ef7b0a56'
${ noResults }
boringssl/include/openssl/stack_macros.h

4191 lines
191 KiB
Raw Blame History 

  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. /* MIME_HEADER */

  1434. #define sk_MIME_HEADER_new(comp)                                             \

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

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

  1437.       comp)))

  1438. 

  1439. #define sk_MIME_HEADER_new_null() ((STACK_OF(MIME_HEADER) *)sk_new_null())

  1440. 

  1441. #define sk_MIME_HEADER_num(sk) \

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

  1443. 

  1444. #define sk_MIME_HEADER_zero(sk) \

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

  1446. 

  1447. #define sk_MIME_HEADER_value(sk, i) \

  1448.   ((MIME_HEADER *)sk_value(         \

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

  1450. 

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

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

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

  1454. 

  1455. #define sk_MIME_HEADER_free(sk) \

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

  1457. 

  1458. #define sk_MIME_HEADER_pop_free(sk, free_func)             \

  1459.   sk_pop_free(                                             \

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

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

  1462. 

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

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

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

  1466. 

  1467. #define sk_MIME_HEADER_delete(sk, where) \

  1468.   ((MIME_HEADER *)sk_delete(             \

  1469.       CHECKED_CAST(_STACK *, STACK_OF(MIME_HEADER) *, sk), (where)))

  1470. 

  1471. #define sk_MIME_HEADER_delete_ptr(sk, p)                   \

  1472.   ((MIME_HEADER *)sk_delete_ptr(                           \

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

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

  1475. 

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

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

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

  1479. 

  1480. #define sk_MIME_HEADER_shift(sk) \

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

  1482. 

  1483. #define sk_MIME_HEADER_push(sk, p)                             \

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

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

  1486. 

  1487. #define sk_MIME_HEADER_pop(sk) \

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

  1489. 

  1490. #define sk_MIME_HEADER_dup(sk)      \

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

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

  1493. 

  1494. #define sk_MIME_HEADER_sort(sk) \

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

  1496. 

  1497. #define sk_MIME_HEADER_is_sorted(sk) \

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

  1499. 

  1500. #define sk_MIME_HEADER_set_cmp_func(sk, comp)                              \

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

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

  1503.       CHECKED_CAST(stack_cmp_func,                                         \

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

  1505.                    comp)))

  1506. 

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

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

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

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

  1511.                    copy_func),                                         \

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

  1513. 

  1514. /* PKCS7_RECIP_INFO */

  1515. #define sk_PKCS7_RECIP_INFO_new(comp)                 \

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

  1517.       stack_cmp_func,                                 \

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

  1519. 

  1520. #define sk_PKCS7_RECIP_INFO_new_null() \

  1521.   ((STACK_OF(PKCS7_RECIP_INFO) *)sk_new_null())

  1522. 

  1523. #define sk_PKCS7_RECIP_INFO_num(sk) \

  1524.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))

  1525. 

  1526. #define sk_PKCS7_RECIP_INFO_zero(sk) \

  1527.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk));

  1528. 

  1529. #define sk_PKCS7_RECIP_INFO_value(sk, i) \

  1530.   ((PKCS7_RECIP_INFO *)sk_value(         \

  1531.       CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk), (i)))

  1532. 

  1533. #define sk_PKCS7_RECIP_INFO_set(sk, i, p)                            \

  1534.   ((PKCS7_RECIP_INFO *)sk_set(                                       \

  1535.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), (i), \

  1536.       CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p)))

  1537. 

  1538. #define sk_PKCS7_RECIP_INFO_free(sk) \

  1539.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))

  1540. 

  1541. #define sk_PKCS7_RECIP_INFO_pop_free(sk, free_func)             \

  1542.   sk_pop_free(                                                  \

  1543.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \

  1544.       CHECKED_CAST(void (*)(void *), void (*)(PKCS7_RECIP_INFO *), free_func))

  1545. 

  1546. #define sk_PKCS7_RECIP_INFO_insert(sk, p, where)                      \

  1547.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \

  1548.             CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p), (where))

  1549. 

  1550. #define sk_PKCS7_RECIP_INFO_delete(sk, where) \

  1551.   ((PKCS7_RECIP_INFO *)sk_delete(             \

  1552.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), (where)))

  1553. 

  1554. #define sk_PKCS7_RECIP_INFO_delete_ptr(sk, p)                   \

  1555.   ((PKCS7_RECIP_INFO *)sk_delete_ptr(                           \

  1556.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \

  1557.       CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p)))

  1558. 

  1559. #define sk_PKCS7_RECIP_INFO_find(sk, out_index, p)                  \

  1560.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \

  1561.           (out_index), CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p))

  1562. 

  1563. #define sk_PKCS7_RECIP_INFO_shift(sk) \

  1564.   ((PKCS7_RECIP_INFO *)sk_shift(      \

  1565.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk)))

  1566. 

  1567. #define sk_PKCS7_RECIP_INFO_push(sk, p)                             \

  1568.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk), \

  1569.           CHECKED_CAST(void *, PKCS7_RECIP_INFO *, p))

  1570. 

  1571. #define sk_PKCS7_RECIP_INFO_pop(sk) \

  1572.   ((PKCS7_RECIP_INFO *)sk_pop(      \

  1573.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk)))

  1574. 

  1575. #define sk_PKCS7_RECIP_INFO_dup(sk)      \

  1576.   ((STACK_OF(PKCS7_RECIP_INFO) *)sk_dup( \

  1577.       CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk)))

  1578. 

  1579. #define sk_PKCS7_RECIP_INFO_sort(sk) \

  1580.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk))

  1581. 

  1582. #define sk_PKCS7_RECIP_INFO_is_sorted(sk) \

  1583.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk))

  1584. 

  1585. #define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, comp)                           \

  1586.   ((int (*)(const PKCS7_RECIP_INFO **a, const PKCS7_RECIP_INFO **b))         \

  1587.        sk_set_cmp_func(                                                      \

  1588.            CHECKED_CAST(_STACK *, STACK_OF(PKCS7_RECIP_INFO) *, sk),         \

  1589.            CHECKED_CAST(stack_cmp_func, int (*)(const PKCS7_RECIP_INFO **a,  \

  1590.                                                 const PKCS7_RECIP_INFO **b), \

  1591.                         comp)))

  1592. 

  1593. #define sk_PKCS7_RECIP_INFO_deep_copy(sk, copy_func, free_func)             \

  1594.   ((STACK_OF(PKCS7_RECIP_INFO) *)sk_deep_copy(                              \

  1595.       CHECKED_CAST(const _STACK *, const STACK_OF(PKCS7_RECIP_INFO) *, sk), \

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

  1597.                    PKCS7_RECIP_INFO *(*)(PKCS7_RECIP_INFO *), copy_func),   \

  1598.       CHECKED_CAST(void (*)(void *), void (*)(PKCS7_RECIP_INFO *),          \

  1599.                    free_func)))

  1600. 

  1601. /* PKCS7_SIGNER_INFO */

  1602. #define sk_PKCS7_SIGNER_INFO_new(comp)                                   \

  1603.   ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_new(CHECKED_CAST(                   \

  1604.       stack_cmp_func,                                                    \

  1605.       int (*)(const PKCS7_SIGNER_INFO **a, const PKCS7_SIGNER_INFO **b), \

  1606.       comp)))

  1607. 

  1608. #define sk_PKCS7_SIGNER_INFO_new_null() \

  1609.   ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_new_null())

  1610. 

  1611. #define sk_PKCS7_SIGNER_INFO_num(sk) \

  1612.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))

  1613. 

  1614. #define sk_PKCS7_SIGNER_INFO_zero(sk) \

  1615.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk));

  1616. 

  1617. #define sk_PKCS7_SIGNER_INFO_value(sk, i) \

  1618.   ((PKCS7_SIGNER_INFO *)sk_value(         \

  1619.       CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk), (i)))

  1620. 

  1621. #define sk_PKCS7_SIGNER_INFO_set(sk, i, p)                            \

  1622.   ((PKCS7_SIGNER_INFO *)sk_set(                                       \

  1623.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), (i), \

  1624.       CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p)))

  1625. 

  1626. #define sk_PKCS7_SIGNER_INFO_free(sk) \

  1627.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))

  1628. 

  1629. #define sk_PKCS7_SIGNER_INFO_pop_free(sk, free_func)                        \

  1630.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk),    \

  1631.               CHECKED_CAST(void (*)(void *), void (*)(PKCS7_SIGNER_INFO *), \

  1632.                            free_func))

  1633. 

  1634. #define sk_PKCS7_SIGNER_INFO_insert(sk, p, where)                      \

  1635.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \

  1636.             CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p), (where))

  1637. 

  1638. #define sk_PKCS7_SIGNER_INFO_delete(sk, where) \

  1639.   ((PKCS7_SIGNER_INFO *)sk_delete(             \

  1640.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), (where)))

  1641. 

  1642. #define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, p)                   \

  1643.   ((PKCS7_SIGNER_INFO *)sk_delete_ptr(                           \

  1644.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \

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

  1646. 

  1647. #define sk_PKCS7_SIGNER_INFO_find(sk, out_index, p)                  \

  1648.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \

  1649.           (out_index), CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p))

  1650. 

  1651. #define sk_PKCS7_SIGNER_INFO_shift(sk) \

  1652.   ((PKCS7_SIGNER_INFO *)sk_shift(      \

  1653.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk)))

  1654. 

  1655. #define sk_PKCS7_SIGNER_INFO_push(sk, p)                             \

  1656.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk), \

  1657.           CHECKED_CAST(void *, PKCS7_SIGNER_INFO *, p))

  1658. 

  1659. #define sk_PKCS7_SIGNER_INFO_pop(sk) \

  1660.   ((PKCS7_SIGNER_INFO *)sk_pop(      \

  1661.       CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk)))

  1662. 

  1663. #define sk_PKCS7_SIGNER_INFO_dup(sk)      \

  1664.   ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_dup( \

  1665.       CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk)))

  1666. 

  1667. #define sk_PKCS7_SIGNER_INFO_sort(sk) \

  1668.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk))

  1669. 

  1670. #define sk_PKCS7_SIGNER_INFO_is_sorted(sk) \

  1671.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk))

  1672. 

  1673. #define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, comp)                           \

  1674.   ((int (*)(const PKCS7_SIGNER_INFO **a, const PKCS7_SIGNER_INFO **b))        \

  1675.        sk_set_cmp_func(                                                       \

  1676.            CHECKED_CAST(_STACK *, STACK_OF(PKCS7_SIGNER_INFO) *, sk),         \

  1677.            CHECKED_CAST(stack_cmp_func, int (*)(const PKCS7_SIGNER_INFO **a,  \

  1678.                                                 const PKCS7_SIGNER_INFO **b), \

  1679.                         comp)))

  1680. 

  1681. #define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copy_func, free_func)             \

  1682.   ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_deep_copy(                              \

  1683.       CHECKED_CAST(const _STACK *, const STACK_OF(PKCS7_SIGNER_INFO) *, sk), \

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

  1685.                    PKCS7_SIGNER_INFO *(*)(PKCS7_SIGNER_INFO *), copy_func),  \

  1686.       CHECKED_CAST(void (*)(void *), void (*)(PKCS7_SIGNER_INFO *),          \

  1687.                    free_func)))

  1688. 

  1689. /* POLICYINFO */

  1690. #define sk_POLICYINFO_new(comp)                                            \

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

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

  1693.       comp)))

  1694. 

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

  1696. 

  1697. #define sk_POLICYINFO_num(sk) \

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

  1699. 

  1700. #define sk_POLICYINFO_zero(sk) \

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

  1702. 

  1703. #define sk_POLICYINFO_value(sk, i) \

  1704.   ((POLICYINFO *)sk_value(         \

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

  1706. 

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

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

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

  1710. 

  1711. #define sk_POLICYINFO_free(sk) \

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

  1713. 

  1714. #define sk_POLICYINFO_pop_free(sk, free_func)             \

  1715.   sk_pop_free(                                            \

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

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

  1718. 

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

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

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

  1722. 

  1723. #define sk_POLICYINFO_delete(sk, where)                                        \

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

  1725.                            (where)))

  1726. 

  1727. #define sk_POLICYINFO_delete_ptr(sk, p)                   \

  1728.   ((POLICYINFO *)sk_delete_ptr(                           \

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

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

  1731. 

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

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

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

  1735. 

  1736. #define sk_POLICYINFO_shift(sk) \

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

  1738. 

  1739. #define sk_POLICYINFO_push(sk, p)                             \

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

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

  1742. 

  1743. #define sk_POLICYINFO_pop(sk) \

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

  1745. 

  1746. #define sk_POLICYINFO_dup(sk)      \

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

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

  1749. 

  1750. #define sk_POLICYINFO_sort(sk) \

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

  1752. 

  1753. #define sk_POLICYINFO_is_sorted(sk) \

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

  1755. 

  1756. #define sk_POLICYINFO_set_cmp_func(sk, comp)                             \

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

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

  1759.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1761.                    comp)))

  1762. 

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

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

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

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

  1767.                    copy_func),                                        \

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

  1769. 

  1770. /* POLICYQUALINFO */

  1771. #define sk_POLICYQUALINFO_new(comp)                 \

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

  1773.       stack_cmp_func,                               \

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

  1775. 

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

  1777. 

  1778. #define sk_POLICYQUALINFO_num(sk) \

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

  1780. 

  1781. #define sk_POLICYQUALINFO_zero(sk) \

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

  1783. 

  1784. #define sk_POLICYQUALINFO_value(sk, i) \

  1785.   ((POLICYQUALINFO *)sk_value(         \

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

  1787. 

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

  1789.   ((POLICYQUALINFO *)sk_set(                                       \

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

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

  1792. 

  1793. #define sk_POLICYQUALINFO_free(sk) \

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

  1795. 

  1796. #define sk_POLICYQUALINFO_pop_free(sk, free_func)             \

  1797.   sk_pop_free(                                                \

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

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

  1800. 

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

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

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

  1804. 

  1805. #define sk_POLICYQUALINFO_delete(sk, where) \

  1806.   ((POLICYQUALINFO *)sk_delete(             \

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

  1808. 

  1809. #define sk_POLICYQUALINFO_delete_ptr(sk, p)                   \

  1810.   ((POLICYQUALINFO *)sk_delete_ptr(                           \

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

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

  1813. 

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

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

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

  1817. 

  1818. #define sk_POLICYQUALINFO_shift(sk) \

  1819.   ((POLICYQUALINFO *)sk_shift(      \

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

  1821. 

  1822. #define sk_POLICYQUALINFO_push(sk, p)                             \

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

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

  1825. 

  1826. #define sk_POLICYQUALINFO_pop(sk) \

  1827.   ((POLICYQUALINFO *)sk_pop(      \

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

  1829. 

  1830. #define sk_POLICYQUALINFO_dup(sk)      \

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

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

  1833. 

  1834. #define sk_POLICYQUALINFO_sort(sk) \

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

  1836. 

  1837. #define sk_POLICYQUALINFO_is_sorted(sk) \

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

  1839. 

  1840. #define sk_POLICYQUALINFO_set_cmp_func(sk, comp)                           \

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

  1842.        sk_set_cmp_func(                                                    \

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

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

  1845.                                                 const POLICYQUALINFO **b), \

  1846.                         comp)))

  1847. 

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

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

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

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

  1852.                    copy_func),                                               \

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

  1854. 

  1855. /* POLICY_MAPPING */

  1856. #define sk_POLICY_MAPPING_new(comp)                 \

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

  1858.       stack_cmp_func,                               \

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

  1860. 

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

  1862. 

  1863. #define sk_POLICY_MAPPING_num(sk) \

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

  1865. 

  1866. #define sk_POLICY_MAPPING_zero(sk) \

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

  1868. 

  1869. #define sk_POLICY_MAPPING_value(sk, i) \

  1870.   ((POLICY_MAPPING *)sk_value(         \

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

  1872. 

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

  1874.   ((POLICY_MAPPING *)sk_set(                                       \

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

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

  1877. 

  1878. #define sk_POLICY_MAPPING_free(sk) \

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

  1880. 

  1881. #define sk_POLICY_MAPPING_pop_free(sk, free_func)             \

  1882.   sk_pop_free(                                                \

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

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

  1885. 

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

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

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

  1889. 

  1890. #define sk_POLICY_MAPPING_delete(sk, where) \

  1891.   ((POLICY_MAPPING *)sk_delete(             \

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

  1893. 

  1894. #define sk_POLICY_MAPPING_delete_ptr(sk, p)                   \

  1895.   ((POLICY_MAPPING *)sk_delete_ptr(                           \

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

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

  1898. 

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

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

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

  1902. 

  1903. #define sk_POLICY_MAPPING_shift(sk) \

  1904.   ((POLICY_MAPPING *)sk_shift(      \

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

  1906. 

  1907. #define sk_POLICY_MAPPING_push(sk, p)                             \

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

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

  1910. 

  1911. #define sk_POLICY_MAPPING_pop(sk) \

  1912.   ((POLICY_MAPPING *)sk_pop(      \

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

  1914. 

  1915. #define sk_POLICY_MAPPING_dup(sk)      \

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

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

  1918. 

  1919. #define sk_POLICY_MAPPING_sort(sk) \

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

  1921. 

  1922. #define sk_POLICY_MAPPING_is_sorted(sk) \

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

  1924. 

  1925. #define sk_POLICY_MAPPING_set_cmp_func(sk, comp)                           \

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

  1927.        sk_set_cmp_func(                                                    \

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

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

  1930.                                                 const POLICY_MAPPING **b), \

  1931.                         comp)))

  1932. 

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

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

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

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

  1937.                    copy_func),                                               \

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

  1939. 

  1940. /* RSA_additional_prime */

  1941. #define sk_RSA_additional_prime_new(comp)                                      \

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

  1943.       stack_cmp_func,                                                          \

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

  1945.       comp)))

  1946. 

  1947. #define sk_RSA_additional_prime_new_null() \

  1948.   ((STACK_OF(RSA_additional_prime) *)sk_new_null())

  1949. 

  1950. #define sk_RSA_additional_prime_num(sk) \

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

  1952. 

  1953. #define sk_RSA_additional_prime_zero(sk) \

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

  1955. 

  1956. #define sk_RSA_additional_prime_value(sk, i)                              \

  1957.   ((RSA_additional_prime *)sk_value(                                      \

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

  1959.       (i)))

  1960. 

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

  1962.   ((RSA_additional_prime *)sk_set(                                       \

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

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

  1965. 

  1966. #define sk_RSA_additional_prime_free(sk) \

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

  1968. 

  1969. #define sk_RSA_additional_prime_pop_free(sk, free_func)                        \

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

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

  1972.                            free_func))

  1973. 

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

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

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

  1977. 

  1978. #define sk_RSA_additional_prime_delete(sk, where) \

  1979.   ((RSA_additional_prime *)sk_delete(             \

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

  1981. 

  1982. #define sk_RSA_additional_prime_delete_ptr(sk, p)                   \

  1983.   ((RSA_additional_prime *)sk_delete_ptr(                           \

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

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

  1986. 

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

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

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

  1990. 

  1991. #define sk_RSA_additional_prime_shift(sk) \

  1992.   ((RSA_additional_prime *)sk_shift(      \

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

  1994. 

  1995. #define sk_RSA_additional_prime_push(sk, p)                             \

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

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

  1998. 

  1999. #define sk_RSA_additional_prime_pop(sk) \

  2000.   ((RSA_additional_prime *)sk_pop(      \

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

  2002. 

  2003. #define sk_RSA_additional_prime_dup(sk)      \

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

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

  2006. 

  2007. #define sk_RSA_additional_prime_sort(sk) \

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

  2009. 

  2010. #define sk_RSA_additional_prime_is_sorted(sk) \

  2011.   sk_is_sorted(                               \

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

  2013. 

  2014. #define sk_RSA_additional_prime_set_cmp_func(sk, comp)                       \

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

  2016.        sk_set_cmp_func(                                                      \

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

  2018.            CHECKED_CAST(stack_cmp_func,                                      \

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

  2020.                                 const RSA_additional_prime **b),             \

  2021.                         comp)))

  2022. 

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

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

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

  2026.                    sk),                                                    \

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

  2028.                    RSA_additional_prime *(*)(RSA_additional_prime *),      \

  2029.                    copy_func),                                             \

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

  2031.                    free_func)))

  2032. 

  2033. /* SSL_COMP */

  2034. #define sk_SSL_COMP_new(comp)                 \

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

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

  2037. 

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

  2039. 

  2040. #define sk_SSL_COMP_num(sk) \

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

  2042. 

  2043. #define sk_SSL_COMP_zero(sk) \

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

  2045. 

  2046. #define sk_SSL_COMP_value(sk, i) \

  2047.   ((SSL_COMP *)sk_value(         \

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

  2049. 

  2050. #define sk_SSL_COMP_set(sk, i, p)                                            \

  2051.   ((SSL_COMP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (i), \

  2052.                       CHECKED_CAST(void *, SSL_COMP *, p)))

  2053. 

  2054. #define sk_SSL_COMP_free(sk) \

  2055.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))

  2056. 

  2057. #define sk_SSL_COMP_pop_free(sk, free_func)                     \

  2058.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  2059.               CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func))

  2060. 

  2061. #define sk_SSL_COMP_insert(sk, p, where)                      \

  2062.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  2063.             CHECKED_CAST(void *, SSL_COMP *, p), (where))

  2064. 

  2065. #define sk_SSL_COMP_delete(sk, where)                                      \

  2066.   ((SSL_COMP *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  2067.                          (where)))

  2068. 

  2069. #define sk_SSL_COMP_delete_ptr(sk, p)                                          \

  2070.   ((SSL_COMP *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  2071.                              CHECKED_CAST(void *, SSL_COMP *, p)))

  2072. 

  2073. #define sk_SSL_COMP_find(sk, out_index, p)                               \

  2074.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (out_index), \

  2075.           CHECKED_CAST(void *, SSL_COMP *, p))

  2076. 

  2077. #define sk_SSL_COMP_shift(sk) \

  2078.   ((SSL_COMP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))

  2079. 

  2080. #define sk_SSL_COMP_push(sk, p)                             \

  2081.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \

  2082.           CHECKED_CAST(void *, SSL_COMP *, p))

  2083. 

  2084. #define sk_SSL_COMP_pop(sk) \

  2085.   ((SSL_COMP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))

  2086. 

  2087. #define sk_SSL_COMP_dup(sk)      \

  2088.   ((STACK_OF(SSL_COMP) *)sk_dup( \

  2089.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk)))

  2090. 

  2091. #define sk_SSL_COMP_sort(sk) \

  2092.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))

  2093. 

  2094. #define sk_SSL_COMP_is_sorted(sk) \

  2095.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_COMP) *, sk))

  2096. 

  2097. #define sk_SSL_COMP_set_cmp_func(sk, comp)                           \

  2098.   ((int (*)(const SSL_COMP **a, const SSL_COMP **b))sk_set_cmp_func( \

  2099.       CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk),              \

  2100.       CHECKED_CAST(stack_cmp_func,                                   \

  2101.                    int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))

  2102. 

  2103. #define sk_SSL_COMP_deep_copy(sk, copy_func, free_func)                      \

  2104.   ((STACK_OF(SSL_COMP) *)sk_deep_copy(                                       \

  2105.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk),          \

  2106.       CHECKED_CAST(void *(*)(void *), SSL_COMP *(*)(SSL_COMP *), copy_func), \

  2107.       CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func)))

  2108. 

  2109. /* SSL_CUSTOM_EXTENSION */

  2110. #define sk_SSL_CUSTOM_EXTENSION_new(comp)                                      \

  2111.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new(CHECKED_CAST(                      \

  2112.       stack_cmp_func,                                                          \

  2113.       int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b), \

  2114.       comp)))

  2115. 

  2116. #define sk_SSL_CUSTOM_EXTENSION_new_null() \

  2117.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null())

  2118. 

  2119. #define sk_SSL_CUSTOM_EXTENSION_num(sk) \

  2120.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2121. 

  2122. #define sk_SSL_CUSTOM_EXTENSION_zero(sk) \

  2123.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk));

  2124. 

  2125. #define sk_SSL_CUSTOM_EXTENSION_value(sk, i)                              \

  2126.   ((SSL_CUSTOM_EXTENSION *)sk_value(                                      \

  2127.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2128.       (i)))

  2129. 

  2130. #define sk_SSL_CUSTOM_EXTENSION_set(sk, i, p)                            \

  2131.   ((SSL_CUSTOM_EXTENSION *)sk_set(                                       \

  2132.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (i), \

  2133.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  2134. 

  2135. #define sk_SSL_CUSTOM_EXTENSION_free(sk) \

  2136.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2137. 

  2138. #define sk_SSL_CUSTOM_EXTENSION_pop_free(sk, free_func)                        \

  2139.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),    \

  2140.               CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \

  2141.                            free_func))

  2142. 

  2143. #define sk_SSL_CUSTOM_EXTENSION_insert(sk, p, where)                      \

  2144.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2145.             CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p), (where))

  2146. 

  2147. #define sk_SSL_CUSTOM_EXTENSION_delete(sk, where) \

  2148.   ((SSL_CUSTOM_EXTENSION *)sk_delete(             \

  2149.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (where)))

  2150. 

  2151. #define sk_SSL_CUSTOM_EXTENSION_delete_ptr(sk, p)                   \

  2152.   ((SSL_CUSTOM_EXTENSION *)sk_delete_ptr(                           \

  2153.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2154.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  2155. 

  2156. #define sk_SSL_CUSTOM_EXTENSION_find(sk, out_index, p)                  \

  2157.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2158.           (out_index), CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  2159. 

  2160. #define sk_SSL_CUSTOM_EXTENSION_shift(sk) \

  2161.   ((SSL_CUSTOM_EXTENSION *)sk_shift(      \

  2162.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2163. 

  2164. #define sk_SSL_CUSTOM_EXTENSION_push(sk, p)                             \

  2165.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2166.           CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  2167. 

  2168. #define sk_SSL_CUSTOM_EXTENSION_pop(sk) \

  2169.   ((SSL_CUSTOM_EXTENSION *)sk_pop(      \

  2170.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2171. 

  2172. #define sk_SSL_CUSTOM_EXTENSION_dup(sk)      \

  2173.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_dup( \

  2174.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2175. 

  2176. #define sk_SSL_CUSTOM_EXTENSION_sort(sk) \

  2177.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2178. 

  2179. #define sk_SSL_CUSTOM_EXTENSION_is_sorted(sk) \

  2180.   sk_is_sorted(                               \

  2181.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2182. 

  2183. #define sk_SSL_CUSTOM_EXTENSION_set_cmp_func(sk, comp)                       \

  2184.   ((int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b)) \

  2185.        sk_set_cmp_func(                                                      \

  2186.            CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),     \

  2187.            CHECKED_CAST(stack_cmp_func,                                      \

  2188.                         int (*)(const SSL_CUSTOM_EXTENSION **a,              \

  2189.                                 const SSL_CUSTOM_EXTENSION **b),             \

  2190.                         comp)))

  2191. 

  2192. #define sk_SSL_CUSTOM_EXTENSION_deep_copy(sk, copy_func, free_func)        \

  2193.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_deep_copy(                         \

  2194.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \

  2195.                    sk),                                                    \

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

  2197.                    SSL_CUSTOM_EXTENSION *(*)(SSL_CUSTOM_EXTENSION *),      \

  2198.                    copy_func),                                             \

  2199.       CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *),     \

  2200.                    free_func)))

  2201. 

  2202. /* STACK_OF_X509_NAME_ENTRY */

  2203. #define sk_STACK_OF_X509_NAME_ENTRY_new(comp)                      \

  2204.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST(      \

  2205.       stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a,  \

  2206.                               const STACK_OF_X509_NAME_ENTRY **b), \

  2207.       comp)))

  2208. 

  2209. #define sk_STACK_OF_X509_NAME_ENTRY_new_null() \

  2210.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())

  2211. 

  2212. #define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \

  2213.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2214. 

  2215. #define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \

  2216.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk));

  2217. 

  2218. #define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i)                              \

  2219.   ((STACK_OF_X509_NAME_ENTRY *)sk_value(                                      \

  2220.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2221.       (i)))

  2222. 

  2223. #define sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p)                            \

  2224.   ((STACK_OF_X509_NAME_ENTRY *)sk_set(                                       \

  2225.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \

  2226.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  2227. 

  2228. #define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \

  2229.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2230. 

  2231. #define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func)                \

  2232.   sk_pop_free(                                                             \

  2233.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk),    \

  2234.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \

  2235.                    free_func))

  2236. 

  2237. #define sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where)                      \

  2238.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2239.             CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where))

  2240. 

  2241. #define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where)                   \

  2242.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete(                               \

  2243.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2244.       (where)))

  2245. 

  2246. #define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  2247.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr(                           \

  2248.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2249.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  2250. 

  2251. #define sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  2252.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2253.           (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  2254. 

  2255. #define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \

  2256.   ((STACK_OF_X509_NAME_ENTRY *)sk_shift(      \

  2257.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2258. 

  2259. #define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p)                             \

  2260.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2261.           CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  2262. 

  2263. #define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \

  2264.   ((STACK_OF_X509_NAME_ENTRY *)sk_pop(      \

  2265.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2266. 

  2267. #define sk_STACK_OF_X509_NAME_ENTRY_dup(sk)      \

  2268.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup( \

  2269.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2270. 

  2271. #define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \

  2272.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2273. 

  2274. #define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \

  2275.   sk_is_sorted(                                   \

  2276.       CHECKED_CAST(_STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2277. 

  2278. #define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp)                   \

  2279.   ((int (*)(const STACK_OF_X509_NAME_ENTRY **a,                              \

  2280.             const STACK_OF_X509_NAME_ENTRY **b))                             \

  2281.        sk_set_cmp_func(                                                      \

  2282.            CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2283.            CHECKED_CAST(stack_cmp_func,                                      \

  2284.                         int (*)(const STACK_OF_X509_NAME_ENTRY **a,          \

  2285.                                 const STACK_OF_X509_NAME_ENTRY **b),         \

  2286.                         comp)))

  2287. 

  2288. #define sk_STACK_OF_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)        \

  2289.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_deep_copy(                         \

  2290.       CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \

  2291.                    sk),                                                        \

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

  2293.                    STACK_OF_X509_NAME_ENTRY *(*)(STACK_OF_X509_NAME_ENTRY *),  \

  2294.                    copy_func),                                                 \

  2295.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *),     \

  2296.                    free_func)))

  2297. 

  2298. /* SXNETID */

  2299. #define sk_SXNETID_new(comp)                 \

  2300.   ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \

  2301.       stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2302. 

  2303. #define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null())

  2304. 

  2305. #define sk_SXNETID_num(sk) \

  2306.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2307. 

  2308. #define sk_SXNETID_zero(sk) \

  2309.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));

  2310. 

  2311. #define sk_SXNETID_value(sk, i)                                               \

  2312.   ((SXNETID *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk), \

  2313.                        (i)))

  2314. 

  2315. #define sk_SXNETID_set(sk, i, p)                                           \

  2316.   ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \

  2317.                      CHECKED_CAST(void *, SXNETID *, p)))

  2318. 

  2319. #define sk_SXNETID_free(sk) \

  2320.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2321. 

  2322. #define sk_SXNETID_pop_free(sk, free_func)                     \

  2323.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2324.               CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))

  2325. 

  2326. #define sk_SXNETID_insert(sk, p, where)                      \

  2327.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2328.             CHECKED_CAST(void *, SXNETID *, p), (where))

  2329. 

  2330. #define sk_SXNETID_delete(sk, where)                                     \

  2331.   ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2332.                         (where)))

  2333. 

  2334. #define sk_SXNETID_delete_ptr(sk, p)                                         \

  2335.   ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2336.                             CHECKED_CAST(void *, SXNETID *, p)))

  2337. 

  2338. #define sk_SXNETID_find(sk, out_index, p)                               \

  2339.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \

  2340.           CHECKED_CAST(void *, SXNETID *, p))

  2341. 

  2342. #define sk_SXNETID_shift(sk) \

  2343.   ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2344. 

  2345. #define sk_SXNETID_push(sk, p)                             \

  2346.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2347.           CHECKED_CAST(void *, SXNETID *, p))

  2348. 

  2349. #define sk_SXNETID_pop(sk) \

  2350.   ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2351. 

  2352. #define sk_SXNETID_dup(sk)      \

  2353.   ((STACK_OF(SXNETID) *)sk_dup( \

  2354.       CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk)))

  2355. 

  2356. #define sk_SXNETID_sort(sk) \

  2357.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2358. 

  2359. #define sk_SXNETID_is_sorted(sk) \

  2360.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk))

  2361. 

  2362. #define sk_SXNETID_set_cmp_func(sk, comp)                          \

  2363.   ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \

  2364.       CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk),             \

  2365.       CHECKED_CAST(stack_cmp_func,                                 \

  2366.                    int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2367. 

  2368. #define sk_SXNETID_deep_copy(sk, copy_func, free_func)                     \

  2369.   ((STACK_OF(SXNETID) *)sk_deep_copy(                                      \

  2370.       CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk),         \

  2371.       CHECKED_CAST(void *(*)(void *), SXNETID *(*)(SXNETID *), copy_func), \

  2372.       CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func)))

  2373. 

  2374. /* X509 */

  2375. #define sk_X509_new(comp)                 \

  2376.   ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \

  2377.       stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))

  2378. 

  2379. #define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null())

  2380. 

  2381. #define sk_X509_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2382. 

  2383. #define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));

  2384. 

  2385. #define sk_X509_value(sk, i) \

  2386.   ((X509 *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk), (i)))

  2387. 

  2388. #define sk_X509_set(sk, i, p)                                        \

  2389.   ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \

  2390.                   CHECKED_CAST(void *, X509 *, p)))

  2391. 

  2392. #define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2393. 

  2394. #define sk_X509_pop_free(sk, free_func)                     \

  2395.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2396.               CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))

  2397. 

  2398. #define sk_X509_insert(sk, p, where)                      \

  2399.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2400.             CHECKED_CAST(void *, X509 *, p), (where))

  2401. 

  2402. #define sk_X509_delete(sk, where) \

  2403.   ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))

  2404. 

  2405. #define sk_X509_delete_ptr(sk, p)                                      \

  2406.   ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2407.                          CHECKED_CAST(void *, X509 *, p)))

  2408. 

  2409. #define sk_X509_find(sk, out_index, p)                               \

  2410.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \

  2411.           CHECKED_CAST(void *, X509 *, p))

  2412. 

  2413. #define sk_X509_shift(sk) \

  2414.   ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2415. 

  2416. #define sk_X509_push(sk, p)                             \

  2417.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2418.           CHECKED_CAST(void *, X509 *, p))

  2419. 

  2420. #define sk_X509_pop(sk) \

  2421.   ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2422. 

  2423. #define sk_X509_dup(sk) \

  2424.   ((STACK_OF(X509) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk)))

  2425. 

  2426. #define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2427. 

  2428. #define sk_X509_is_sorted(sk) \

  2429.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk))

  2430. 

  2431. #define sk_X509_set_cmp_func(sk, comp)                                      \

  2432.   ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func(                \

  2433.       CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk),                         \

  2434.       CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \

  2435.                    comp)))

  2436. 

  2437. #define sk_X509_deep_copy(sk, copy_func, free_func)                  \

  2438.   ((STACK_OF(X509) *)sk_deep_copy(                                   \

  2439.       CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk),      \

  2440.       CHECKED_CAST(void *(*)(void *), X509 *(*)(X509 *), copy_func), \

  2441.       CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func)))

  2442. 

  2443. /* X509V3_EXT_METHOD */

  2444. #define sk_X509V3_EXT_METHOD_new(comp)                                   \

  2445.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST(                   \

  2446.       stack_cmp_func,                                                    \

  2447.       int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \

  2448.       comp)))

  2449. 

  2450. #define sk_X509V3_EXT_METHOD_new_null() \

  2451.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())

  2452. 

  2453. #define sk_X509V3_EXT_METHOD_num(sk) \

  2454.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2455. 

  2456. #define sk_X509V3_EXT_METHOD_zero(sk) \

  2457.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));

  2458. 

  2459. #define sk_X509V3_EXT_METHOD_value(sk, i) \

  2460.   ((X509V3_EXT_METHOD *)sk_value(         \

  2461.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), (i)))

  2462. 

  2463. #define sk_X509V3_EXT_METHOD_set(sk, i, p)                            \

  2464.   ((X509V3_EXT_METHOD *)sk_set(                                       \

  2465.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \

  2466.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2467. 

  2468. #define sk_X509V3_EXT_METHOD_free(sk) \

  2469.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2470. 

  2471. #define sk_X509V3_EXT_METHOD_pop_free(sk, free_func)                        \

  2472.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),    \

  2473.               CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \

  2474.                            free_func))

  2475. 

  2476. #define sk_X509V3_EXT_METHOD_insert(sk, p, where)                      \

  2477.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2478.             CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))

  2479. 

  2480. #define sk_X509V3_EXT_METHOD_delete(sk, where) \

  2481.   ((X509V3_EXT_METHOD *)sk_delete(             \

  2482.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))

  2483. 

  2484. #define sk_X509V3_EXT_METHOD_delete_ptr(sk, p)                   \

  2485.   ((X509V3_EXT_METHOD *)sk_delete_ptr(                           \

  2486.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2487.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2488. 

  2489. #define sk_X509V3_EXT_METHOD_find(sk, out_index, p)                  \

  2490.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2491.           (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2492. 

  2493. #define sk_X509V3_EXT_METHOD_shift(sk) \

  2494.   ((X509V3_EXT_METHOD *)sk_shift(      \

  2495.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2496. 

  2497. #define sk_X509V3_EXT_METHOD_push(sk, p)                             \

  2498.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2499.           CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2500. 

  2501. #define sk_X509V3_EXT_METHOD_pop(sk) \

  2502.   ((X509V3_EXT_METHOD *)sk_pop(      \

  2503.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2504. 

  2505. #define sk_X509V3_EXT_METHOD_dup(sk)      \

  2506.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \

  2507.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2508. 

  2509. #define sk_X509V3_EXT_METHOD_sort(sk) \

  2510.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2511. 

  2512. #define sk_X509V3_EXT_METHOD_is_sorted(sk) \

  2513.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

  2514. 

  2515. #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp)                           \

  2516.   ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b))        \

  2517.        sk_set_cmp_func(                                                       \

  2518.            CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),         \

  2519.            CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a,  \

  2520.                                                 const X509V3_EXT_METHOD **b), \

  2521.                         comp)))

  2522. 

  2523. #define sk_X509V3_EXT_METHOD_deep_copy(sk, copy_func, free_func)             \

  2524.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_deep_copy(                              \

  2525.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \

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

  2527.                    X509V3_EXT_METHOD *(*)(X509V3_EXT_METHOD *), copy_func),  \

  2528.       CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *),          \

  2529.                    free_func)))

  2530. 

  2531. /* X509_ALGOR */

  2532. #define sk_X509_ALGOR_new(comp)                                            \

  2533.   ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST(                            \

  2534.       stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \

  2535.       comp)))

  2536. 

  2537. #define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null())

  2538. 

  2539. #define sk_X509_ALGOR_num(sk) \

  2540.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2541. 

  2542. #define sk_X509_ALGOR_zero(sk) \

  2543.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));

  2544. 

  2545. #define sk_X509_ALGOR_value(sk, i) \

  2546.   ((X509_ALGOR *)sk_value(         \

  2547.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))

  2548. 

  2549. #define sk_X509_ALGOR_set(sk, i, p)                                         \

  2550.   ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2551.                         (i), CHECKED_CAST(void *, X509_ALGOR *, p)))

  2552. 

  2553. #define sk_X509_ALGOR_free(sk) \

  2554.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2555. 

  2556. #define sk_X509_ALGOR_pop_free(sk, free_func)             \

  2557.   sk_pop_free(                                            \

  2558.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2559.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))

  2560. 

  2561. #define sk_X509_ALGOR_insert(sk, p, where)                      \

  2562.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2563.             CHECKED_CAST(void *, X509_ALGOR *, p), (where))

  2564. 

  2565. #define sk_X509_ALGOR_delete(sk, where)                                        \

  2566.   ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2567.                            (where)))

  2568. 

  2569. #define sk_X509_ALGOR_delete_ptr(sk, p)                   \

  2570.   ((X509_ALGOR *)sk_delete_ptr(                           \

  2571.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2572.       CHECKED_CAST(void *, X509_ALGOR *, p)))

  2573. 

  2574. #define sk_X509_ALGOR_find(sk, out_index, p)                               \

  2575.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \

  2576.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2577. 

  2578. #define sk_X509_ALGOR_shift(sk) \

  2579.   ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2580. 

  2581. #define sk_X509_ALGOR_push(sk, p)                             \

  2582.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2583.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2584. 

  2585. #define sk_X509_ALGOR_pop(sk) \

  2586.   ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2587. 

  2588. #define sk_X509_ALGOR_dup(sk)      \

  2589.   ((STACK_OF(X509_ALGOR) *)sk_dup( \

  2590.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk)))

  2591. 

  2592. #define sk_X509_ALGOR_sort(sk) \

  2593.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2594. 

  2595. #define sk_X509_ALGOR_is_sorted(sk) \

  2596.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk))

  2597. 

  2598. #define sk_X509_ALGOR_set_cmp_func(sk, comp)                             \

  2599.   ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \

  2600.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk),                \

  2601.       CHECKED_CAST(stack_cmp_func,                                       \

  2602.                    int (*)(const X509_ALGOR **a, const X509_ALGOR **b),  \

  2603.                    comp)))

  2604. 

  2605. #define sk_X509_ALGOR_deep_copy(sk, copy_func, free_func)             \

  2606.   ((STACK_OF(X509_ALGOR) *)sk_deep_copy(                              \

  2607.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), \

  2608.       CHECKED_CAST(void *(*)(void *), X509_ALGOR *(*)(X509_ALGOR *),  \

  2609.                    copy_func),                                        \

  2610.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func)))

  2611. 

  2612. /* X509_ATTRIBUTE */

  2613. #define sk_X509_ATTRIBUTE_new(comp)                 \

  2614.   ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \

  2615.       stack_cmp_func,                               \

  2616.       int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))

  2617. 

  2618. #define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())

  2619. 

  2620. #define sk_X509_ATTRIBUTE_num(sk) \

  2621.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2622. 

  2623. #define sk_X509_ATTRIBUTE_zero(sk) \

  2624.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));

  2625. 

  2626. #define sk_X509_ATTRIBUTE_value(sk, i) \

  2627.   ((X509_ATTRIBUTE *)sk_value(         \

  2628.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), (i)))

  2629. 

  2630. #define sk_X509_ATTRIBUTE_set(sk, i, p)                            \

  2631.   ((X509_ATTRIBUTE *)sk_set(                                       \

  2632.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \

  2633.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2634. 

  2635. #define sk_X509_ATTRIBUTE_free(sk) \

  2636.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2637. 

  2638. #define sk_X509_ATTRIBUTE_pop_free(sk, free_func)             \

  2639.   sk_pop_free(                                                \

  2640.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2641.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))

  2642. 

  2643. #define sk_X509_ATTRIBUTE_insert(sk, p, where)                      \

  2644.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2645.             CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))

  2646. 

  2647. #define sk_X509_ATTRIBUTE_delete(sk, where) \

  2648.   ((X509_ATTRIBUTE *)sk_delete(             \

  2649.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))

  2650. 

  2651. #define sk_X509_ATTRIBUTE_delete_ptr(sk, p)                   \

  2652.   ((X509_ATTRIBUTE *)sk_delete_ptr(                           \

  2653.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2654.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2655. 

  2656. #define sk_X509_ATTRIBUTE_find(sk, out_index, p)                               \

  2657.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \

  2658.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2659. 

  2660. #define sk_X509_ATTRIBUTE_shift(sk) \

  2661.   ((X509_ATTRIBUTE *)sk_shift(      \

  2662.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2663. 

  2664. #define sk_X509_ATTRIBUTE_push(sk, p)                             \

  2665.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2666.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2667. 

  2668. #define sk_X509_ATTRIBUTE_pop(sk) \

  2669.   ((X509_ATTRIBUTE *)sk_pop(      \

  2670.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2671. 

  2672. #define sk_X509_ATTRIBUTE_dup(sk)      \

  2673.   ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \

  2674.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))

  2675. 

  2676. #define sk_X509_ATTRIBUTE_sort(sk) \

  2677.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2678. 

  2679. #define sk_X509_ATTRIBUTE_is_sorted(sk) \

  2680.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

  2681. 

  2682. #define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp)                           \

  2683.   ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b))           \

  2684.        sk_set_cmp_func(                                                    \

  2685.            CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk),         \

  2686.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a,  \

  2687.                                                 const X509_ATTRIBUTE **b), \

  2688.                         comp)))

  2689. 

  2690. #define sk_X509_ATTRIBUTE_deep_copy(sk, copy_func, free_func)                \

  2691.   ((STACK_OF(X509_ATTRIBUTE) *)sk_deep_copy(                                 \

  2692.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk),    \

  2693.       CHECKED_CAST(void *(*)(void *), X509_ATTRIBUTE *(*)(X509_ATTRIBUTE *), \

  2694.                    copy_func),                                               \

  2695.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func)))

  2696. 

  2697. /* X509_CRL */

  2698. #define sk_X509_CRL_new(comp)                 \

  2699.   ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \

  2700.       stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2701. 

  2702. #define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null())

  2703. 

  2704. #define sk_X509_CRL_num(sk) \

  2705.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2706. 

  2707. #define sk_X509_CRL_zero(sk) \

  2708.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));

  2709. 

  2710. #define sk_X509_CRL_value(sk, i) \

  2711.   ((X509_CRL *)sk_value(         \

  2712.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk), (i)))

  2713. 

  2714. #define sk_X509_CRL_set(sk, i, p)                                            \

  2715.   ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \

  2716.                       CHECKED_CAST(void *, X509_CRL *, p)))

  2717. 

  2718. #define sk_X509_CRL_free(sk) \

  2719.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2720. 

  2721. #define sk_X509_CRL_pop_free(sk, free_func)                     \

  2722.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2723.               CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))

  2724. 

  2725. #define sk_X509_CRL_insert(sk, p, where)                      \

  2726.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2727.             CHECKED_CAST(void *, X509_CRL *, p), (where))

  2728. 

  2729. #define sk_X509_CRL_delete(sk, where)                                      \

  2730.   ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2731.                          (where)))

  2732. 

  2733. #define sk_X509_CRL_delete_ptr(sk, p)                                          \

  2734.   ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2735.                              CHECKED_CAST(void *, X509_CRL *, p)))

  2736. 

  2737. #define sk_X509_CRL_find(sk, out_index, p)                               \

  2738.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \

  2739.           CHECKED_CAST(void *, X509_CRL *, p))

  2740. 

  2741. #define sk_X509_CRL_shift(sk) \

  2742.   ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2743. 

  2744. #define sk_X509_CRL_push(sk, p)                             \

  2745.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2746.           CHECKED_CAST(void *, X509_CRL *, p))

  2747. 

  2748. #define sk_X509_CRL_pop(sk) \

  2749.   ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2750. 

  2751. #define sk_X509_CRL_dup(sk)      \

  2752.   ((STACK_OF(X509_CRL) *)sk_dup( \

  2753.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk)))

  2754. 

  2755. #define sk_X509_CRL_sort(sk) \

  2756.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2757. 

  2758. #define sk_X509_CRL_is_sorted(sk) \

  2759.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk))

  2760. 

  2761. #define sk_X509_CRL_set_cmp_func(sk, comp)                           \

  2762.   ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \

  2763.       CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk),              \

  2764.       CHECKED_CAST(stack_cmp_func,                                   \

  2765.                    int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2766. 

  2767. #define sk_X509_CRL_deep_copy(sk, copy_func, free_func)                      \

  2768.   ((STACK_OF(X509_CRL) *)sk_deep_copy(                                       \

  2769.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk),          \

  2770.       CHECKED_CAST(void *(*)(void *), X509_CRL *(*)(X509_CRL *), copy_func), \

  2771.       CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func)))

  2772. 

  2773. /* X509_EXTENSION */

  2774. #define sk_X509_EXTENSION_new(comp)                 \

  2775.   ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \

  2776.       stack_cmp_func,                               \

  2777.       int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))

  2778. 

  2779. #define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null())

  2780. 

  2781. #define sk_X509_EXTENSION_num(sk) \

  2782.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2783. 

  2784. #define sk_X509_EXTENSION_zero(sk) \

  2785.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));

  2786. 

  2787. #define sk_X509_EXTENSION_value(sk, i) \

  2788.   ((X509_EXTENSION *)sk_value(         \

  2789.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk), (i)))

  2790. 

  2791. #define sk_X509_EXTENSION_set(sk, i, p)                            \

  2792.   ((X509_EXTENSION *)sk_set(                                       \

  2793.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \

  2794.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2795. 

  2796. #define sk_X509_EXTENSION_free(sk) \

  2797.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2798. 

  2799. #define sk_X509_EXTENSION_pop_free(sk, free_func)             \

  2800.   sk_pop_free(                                                \

  2801.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2802.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))

  2803. 

  2804. #define sk_X509_EXTENSION_insert(sk, p, where)                      \

  2805.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2806.             CHECKED_CAST(void *, X509_EXTENSION *, p), (where))

  2807. 

  2808. #define sk_X509_EXTENSION_delete(sk, where) \

  2809.   ((X509_EXTENSION *)sk_delete(             \

  2810.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))

  2811. 

  2812. #define sk_X509_EXTENSION_delete_ptr(sk, p)                   \

  2813.   ((X509_EXTENSION *)sk_delete_ptr(                           \

  2814.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2815.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2816. 

  2817. #define sk_X509_EXTENSION_find(sk, out_index, p)                               \

  2818.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \

  2819.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2820. 

  2821. #define sk_X509_EXTENSION_shift(sk) \

  2822.   ((X509_EXTENSION *)sk_shift(      \

  2823.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2824. 

  2825. #define sk_X509_EXTENSION_push(sk, p)                             \

  2826.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2827.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2828. 

  2829. #define sk_X509_EXTENSION_pop(sk) \

  2830.   ((X509_EXTENSION *)sk_pop(      \

  2831.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2832. 

  2833. #define sk_X509_EXTENSION_dup(sk)      \

  2834.   ((STACK_OF(X509_EXTENSION) *)sk_dup( \

  2835.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk)))

  2836. 

  2837. #define sk_X509_EXTENSION_sort(sk) \

  2838.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2839. 

  2840. #define sk_X509_EXTENSION_is_sorted(sk) \

  2841.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk))

  2842. 

  2843. #define sk_X509_EXTENSION_set_cmp_func(sk, comp)                           \

  2844.   ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b))           \

  2845.        sk_set_cmp_func(                                                    \

  2846.            CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk),         \

  2847.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a,  \

  2848.                                                 const X509_EXTENSION **b), \

  2849.                         comp)))

  2850. 

  2851. #define sk_X509_EXTENSION_deep_copy(sk, copy_func, free_func)                \

  2852.   ((STACK_OF(X509_EXTENSION) *)sk_deep_copy(                                 \

  2853.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk),    \

  2854.       CHECKED_CAST(void *(*)(void *), X509_EXTENSION *(*)(X509_EXTENSION *), \

  2855.                    copy_func),                                               \

  2856.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func)))

  2857. 

  2858. /* X509_INFO */

  2859. #define sk_X509_INFO_new(comp)     \

  2860.   ((STACK_OF(X509_INFO) *)sk_new(  \

  2861.       CHECKED_CAST(stack_cmp_func, \

  2862.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2863. 

  2864. #define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null())

  2865. 

  2866. #define sk_X509_INFO_num(sk) \

  2867.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2868. 

  2869. #define sk_X509_INFO_zero(sk) \

  2870.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));

  2871. 

  2872. #define sk_X509_INFO_value(sk, i) \

  2873.   ((X509_INFO *)sk_value(         \

  2874.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk), (i)))

  2875. 

  2876. #define sk_X509_INFO_set(sk, i, p)                                             \

  2877.   ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \

  2878.                        CHECKED_CAST(void *, X509_INFO *, p)))

  2879. 

  2880. #define sk_X509_INFO_free(sk) \

  2881.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2882. 

  2883. #define sk_X509_INFO_pop_free(sk, free_func)             \

  2884.   sk_pop_free(                                           \

  2885.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2886.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))

  2887. 

  2888. #define sk_X509_INFO_insert(sk, p, where)                      \

  2889.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2890.             CHECKED_CAST(void *, X509_INFO *, p), (where))

  2891. 

  2892. #define sk_X509_INFO_delete(sk, where)                                       \

  2893.   ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2894.                           (where)))

  2895. 

  2896. #define sk_X509_INFO_delete_ptr(sk, p)                   \

  2897.   ((X509_INFO *)sk_delete_ptr(                           \

  2898.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2899.       CHECKED_CAST(void *, X509_INFO *, p)))

  2900. 

  2901. #define sk_X509_INFO_find(sk, out_index, p)                               \

  2902.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \

  2903.           CHECKED_CAST(void *, X509_INFO *, p))

  2904. 

  2905. #define sk_X509_INFO_shift(sk) \

  2906.   ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2907. 

  2908. #define sk_X509_INFO_push(sk, p)                             \

  2909.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2910.           CHECKED_CAST(void *, X509_INFO *, p))

  2911. 

  2912. #define sk_X509_INFO_pop(sk) \

  2913.   ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2914. 

  2915. #define sk_X509_INFO_dup(sk)      \

  2916.   ((STACK_OF(X509_INFO) *)sk_dup( \

  2917.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk)))

  2918. 

  2919. #define sk_X509_INFO_sort(sk) \

  2920.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2921. 

  2922. #define sk_X509_INFO_is_sorted(sk) \

  2923.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk))

  2924. 

  2925. #define sk_X509_INFO_set_cmp_func(sk, comp)                            \

  2926.   ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \

  2927.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk),               \

  2928.       CHECKED_CAST(stack_cmp_func,                                     \

  2929.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2930. 

  2931. #define sk_X509_INFO_deep_copy(sk, copy_func, free_func)                       \

  2932.   ((STACK_OF(X509_INFO) *)sk_deep_copy(                                        \

  2933.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk),           \

  2934.       CHECKED_CAST(void *(*)(void *), X509_INFO *(*)(X509_INFO *), copy_func), \

  2935.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func)))

  2936. 

  2937. /* X509_LOOKUP */

  2938. #define sk_X509_LOOKUP_new(comp)                                             \

  2939.   ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST(                             \

  2940.       stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \

  2941.       comp)))

  2942. 

  2943. #define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null())

  2944. 

  2945. #define sk_X509_LOOKUP_num(sk) \

  2946.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2947. 

  2948. #define sk_X509_LOOKUP_zero(sk) \

  2949.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));

  2950. 

  2951. #define sk_X509_LOOKUP_value(sk, i) \

  2952.   ((X509_LOOKUP *)sk_value(         \

  2953.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))

  2954. 

  2955. #define sk_X509_LOOKUP_set(sk, i, p)                                          \

  2956.   ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2957.                          (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2958. 

  2959. #define sk_X509_LOOKUP_free(sk) \

  2960.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2961. 

  2962. #define sk_X509_LOOKUP_pop_free(sk, free_func)             \

  2963.   sk_pop_free(                                             \

  2964.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2965.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))

  2966. 

  2967. #define sk_X509_LOOKUP_insert(sk, p, where)                      \

  2968.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2969.             CHECKED_CAST(void *, X509_LOOKUP *, p), (where))

  2970. 

  2971. #define sk_X509_LOOKUP_delete(sk, where) \

  2972.   ((X509_LOOKUP *)sk_delete(             \

  2973.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))

  2974. 

  2975. #define sk_X509_LOOKUP_delete_ptr(sk, p)                   \

  2976.   ((X509_LOOKUP *)sk_delete_ptr(                           \

  2977.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2978.       CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2979. 

  2980. #define sk_X509_LOOKUP_find(sk, out_index, p)                               \

  2981.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \

  2982.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2983. 

  2984. #define sk_X509_LOOKUP_shift(sk) \

  2985.   ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2986. 

  2987. #define sk_X509_LOOKUP_push(sk, p)                             \

  2988.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2989.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2990. 

  2991. #define sk_X509_LOOKUP_pop(sk) \

  2992.   ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2993. 

  2994. #define sk_X509_LOOKUP_dup(sk)      \

  2995.   ((STACK_OF(X509_LOOKUP) *)sk_dup( \

  2996.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk)))

  2997. 

  2998. #define sk_X509_LOOKUP_sort(sk) \

  2999.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  3000. 

  3001. #define sk_X509_LOOKUP_is_sorted(sk) \

  3002.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk))

  3003. 

  3004. #define sk_X509_LOOKUP_set_cmp_func(sk, comp)                              \

  3005.   ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \

  3006.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk),                 \

  3007.       CHECKED_CAST(stack_cmp_func,                                         \

  3008.                    int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b),  \

  3009.                    comp)))

  3010. 

  3011. #define sk_X509_LOOKUP_deep_copy(sk, copy_func, free_func)             \

  3012.   ((STACK_OF(X509_LOOKUP) *)sk_deep_copy(                              \

  3013.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), \

  3014.       CHECKED_CAST(void *(*)(void *), X509_LOOKUP *(*)(X509_LOOKUP *), \

  3015.                    copy_func),                                         \

  3016.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func)))

  3017. 

  3018. /* X509_NAME */

  3019. #define sk_X509_NAME_new(comp)     \

  3020.   ((STACK_OF(X509_NAME) *)sk_new(  \

  3021.       CHECKED_CAST(stack_cmp_func, \

  3022.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  3023. 

  3024. #define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null())

  3025. 

  3026. #define sk_X509_NAME_num(sk) \

  3027.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  3028. 

  3029. #define sk_X509_NAME_zero(sk) \

  3030.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));

  3031. 

  3032. #define sk_X509_NAME_value(sk, i) \

  3033.   ((X509_NAME *)sk_value(         \

  3034.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk), (i)))

  3035. 

  3036. #define sk_X509_NAME_set(sk, i, p)                                             \

  3037.   ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \

  3038.                        CHECKED_CAST(void *, X509_NAME *, p)))

  3039. 

  3040. #define sk_X509_NAME_free(sk) \

  3041.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  3042. 

  3043. #define sk_X509_NAME_pop_free(sk, free_func)             \

  3044.   sk_pop_free(                                           \

  3045.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  3046.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))

  3047. 

  3048. #define sk_X509_NAME_insert(sk, p, where)                      \

  3049.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  3050.             CHECKED_CAST(void *, X509_NAME *, p), (where))

  3051. 

  3052. #define sk_X509_NAME_delete(sk, where)                                       \

  3053.   ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  3054.                           (where)))

  3055. 

  3056. #define sk_X509_NAME_delete_ptr(sk, p)                   \

  3057.   ((X509_NAME *)sk_delete_ptr(                           \

  3058.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  3059.       CHECKED_CAST(void *, X509_NAME *, p)))

  3060. 

  3061. #define sk_X509_NAME_find(sk, out_index, p)                               \

  3062.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \

  3063.           CHECKED_CAST(void *, X509_NAME *, p))

  3064. 

  3065. #define sk_X509_NAME_shift(sk) \

  3066.   ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  3067. 

  3068. #define sk_X509_NAME_push(sk, p)                             \

  3069.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  3070.           CHECKED_CAST(void *, X509_NAME *, p))

  3071. 

  3072. #define sk_X509_NAME_pop(sk) \

  3073.   ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  3074. 

  3075. #define sk_X509_NAME_dup(sk)      \

  3076.   ((STACK_OF(X509_NAME) *)sk_dup( \

  3077.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk)))

  3078. 

  3079. #define sk_X509_NAME_sort(sk) \

  3080.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  3081. 

  3082. #define sk_X509_NAME_is_sorted(sk) \

  3083.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk))

  3084. 

  3085. #define sk_X509_NAME_set_cmp_func(sk, comp)                            \

  3086.   ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \

  3087.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk),               \

  3088.       CHECKED_CAST(stack_cmp_func,                                     \

  3089.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  3090. 

  3091. #define sk_X509_NAME_deep_copy(sk, copy_func, free_func)                       \

  3092.   ((STACK_OF(X509_NAME) *)sk_deep_copy(                                        \

  3093.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk),           \

  3094.       CHECKED_CAST(void *(*)(void *), X509_NAME *(*)(X509_NAME *), copy_func), \

  3095.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func)))

  3096. 

  3097. /* X509_NAME_ENTRY */

  3098. #define sk_X509_NAME_ENTRY_new(comp)                 \

  3099.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \

  3100.       stack_cmp_func,                                \

  3101.       int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))

  3102. 

  3103. #define sk_X509_NAME_ENTRY_new_null() \

  3104.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())

  3105. 

  3106. #define sk_X509_NAME_ENTRY_num(sk) \

  3107.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  3108. 

  3109. #define sk_X509_NAME_ENTRY_zero(sk) \

  3110.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));

  3111. 

  3112. #define sk_X509_NAME_ENTRY_value(sk, i) \

  3113.   ((X509_NAME_ENTRY *)sk_value(         \

  3114.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), (i)))

  3115. 

  3116. #define sk_X509_NAME_ENTRY_set(sk, i, p)                            \

  3117.   ((X509_NAME_ENTRY *)sk_set(                                       \

  3118.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \

  3119.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  3120. 

  3121. #define sk_X509_NAME_ENTRY_free(sk) \

  3122.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  3123. 

  3124. #define sk_X509_NAME_ENTRY_pop_free(sk, free_func)             \

  3125.   sk_pop_free(                                                 \

  3126.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3127.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))

  3128. 

  3129. #define sk_X509_NAME_ENTRY_insert(sk, p, where)                      \

  3130.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3131.             CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))

  3132. 

  3133. #define sk_X509_NAME_ENTRY_delete(sk, where) \

  3134.   ((X509_NAME_ENTRY *)sk_delete(             \

  3135.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))

  3136. 

  3137. #define sk_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  3138.   ((X509_NAME_ENTRY *)sk_delete_ptr(                           \

  3139.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3140.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  3141. 

  3142. #define sk_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  3143.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3144.           (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  3145. 

  3146. #define sk_X509_NAME_ENTRY_shift(sk) \

  3147.   ((X509_NAME_ENTRY *)sk_shift(      \

  3148.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  3149. 

  3150. #define sk_X509_NAME_ENTRY_push(sk, p)                             \

  3151.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3152.           CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  3153. 

  3154. #define sk_X509_NAME_ENTRY_pop(sk) \

  3155.   ((X509_NAME_ENTRY *)sk_pop(      \

  3156.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  3157. 

  3158. #define sk_X509_NAME_ENTRY_dup(sk)      \

  3159.   ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \

  3160.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))

  3161. 

  3162. #define sk_X509_NAME_ENTRY_sort(sk) \

  3163.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  3164. 

  3165. #define sk_X509_NAME_ENTRY_is_sorted(sk) \

  3166.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

  3167. 

  3168. #define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp)                           \

  3169.   ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b))          \

  3170.        sk_set_cmp_func(                                                     \

  3171.            CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk),         \

  3172.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a,  \

  3173.                                                 const X509_NAME_ENTRY **b), \

  3174.                         comp)))

  3175. 

  3176. #define sk_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)                 \

  3177.   ((STACK_OF(X509_NAME_ENTRY) *)sk_deep_copy(                                  \

  3178.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk),     \

  3179.       CHECKED_CAST(void *(*)(void *), X509_NAME_ENTRY *(*)(X509_NAME_ENTRY *), \

  3180.                    copy_func),                                                 \

  3181.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func)))

  3182. 

  3183. /* X509_OBJECT */

  3184. #define sk_X509_OBJECT_new(comp)                                             \

  3185.   ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST(                             \

  3186.       stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \

  3187.       comp)))

  3188. 

  3189. #define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null())

  3190. 

  3191. #define sk_X509_OBJECT_num(sk) \

  3192.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  3193. 

  3194. #define sk_X509_OBJECT_zero(sk) \

  3195.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));

  3196. 

  3197. #define sk_X509_OBJECT_value(sk, i) \

  3198.   ((X509_OBJECT *)sk_value(         \

  3199.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))

  3200. 

  3201. #define sk_X509_OBJECT_set(sk, i, p)                                          \

  3202.   ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3203.                          (i), CHECKED_CAST(void *, X509_OBJECT *, p)))

  3204. 

  3205. #define sk_X509_OBJECT_free(sk) \

  3206.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  3207. 

  3208. #define sk_X509_OBJECT_pop_free(sk, free_func)             \

  3209.   sk_pop_free(                                             \

  3210.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3211.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))

  3212. 

  3213. #define sk_X509_OBJECT_insert(sk, p, where)                      \

  3214.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3215.             CHECKED_CAST(void *, X509_OBJECT *, p), (where))

  3216. 

  3217. #define sk_X509_OBJECT_delete(sk, where) \

  3218.   ((X509_OBJECT *)sk_delete(             \

  3219.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))

  3220. 

  3221. #define sk_X509_OBJECT_delete_ptr(sk, p)                   \

  3222.   ((X509_OBJECT *)sk_delete_ptr(                           \

  3223.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3224.       CHECKED_CAST(void *, X509_OBJECT *, p)))

  3225. 

  3226. #define sk_X509_OBJECT_find(sk, out_index, p)                               \

  3227.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \

  3228.           CHECKED_CAST(void *, X509_OBJECT *, p))

  3229. 

  3230. #define sk_X509_OBJECT_shift(sk) \

  3231.   ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  3232. 

  3233. #define sk_X509_OBJECT_push(sk, p)                             \

  3234.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3235.           CHECKED_CAST(void *, X509_OBJECT *, p))

  3236. 

  3237. #define sk_X509_OBJECT_pop(sk) \

  3238.   ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  3239. 

  3240. #define sk_X509_OBJECT_dup(sk)      \

  3241.   ((STACK_OF(X509_OBJECT) *)sk_dup( \

  3242.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk)))

  3243. 

  3244. #define sk_X509_OBJECT_sort(sk) \

  3245.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  3246. 

  3247. #define sk_X509_OBJECT_is_sorted(sk) \

  3248.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk))

  3249. 

  3250. #define sk_X509_OBJECT_set_cmp_func(sk, comp)                              \

  3251.   ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \

  3252.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk),                 \

  3253.       CHECKED_CAST(stack_cmp_func,                                         \

  3254.                    int (*)(const X509_OBJECT **a, const X509_OBJECT **b),  \

  3255.                    comp)))

  3256. 

  3257. #define sk_X509_OBJECT_deep_copy(sk, copy_func, free_func)             \

  3258.   ((STACK_OF(X509_OBJECT) *)sk_deep_copy(                              \

  3259.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), \

  3260.       CHECKED_CAST(void *(*)(void *), X509_OBJECT *(*)(X509_OBJECT *), \

  3261.                    copy_func),                                         \

  3262.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func)))

  3263. 

  3264. /* X509_POLICY_DATA */

  3265. #define sk_X509_POLICY_DATA_new(comp)                 \

  3266.   ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \

  3267.       stack_cmp_func,                                 \

  3268.       int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))

  3269. 

  3270. #define sk_X509_POLICY_DATA_new_null() \

  3271.   ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())

  3272. 

  3273. #define sk_X509_POLICY_DATA_num(sk) \

  3274.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3275. 

  3276. #define sk_X509_POLICY_DATA_zero(sk) \

  3277.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));

  3278. 

  3279. #define sk_X509_POLICY_DATA_value(sk, i) \

  3280.   ((X509_POLICY_DATA *)sk_value(         \

  3281.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), (i)))

  3282. 

  3283. #define sk_X509_POLICY_DATA_set(sk, i, p)                            \

  3284.   ((X509_POLICY_DATA *)sk_set(                                       \

  3285.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \

  3286.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3287. 

  3288. #define sk_X509_POLICY_DATA_free(sk) \

  3289.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3290. 

  3291. #define sk_X509_POLICY_DATA_pop_free(sk, free_func)             \

  3292.   sk_pop_free(                                                  \

  3293.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3294.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))

  3295. 

  3296. #define sk_X509_POLICY_DATA_insert(sk, p, where)                      \

  3297.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3298.             CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))

  3299. 

  3300. #define sk_X509_POLICY_DATA_delete(sk, where) \

  3301.   ((X509_POLICY_DATA *)sk_delete(             \

  3302.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))

  3303. 

  3304. #define sk_X509_POLICY_DATA_delete_ptr(sk, p)                   \

  3305.   ((X509_POLICY_DATA *)sk_delete_ptr(                           \

  3306.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3307.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3308. 

  3309. #define sk_X509_POLICY_DATA_find(sk, out_index, p)                  \

  3310.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3311.           (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3312. 

  3313. #define sk_X509_POLICY_DATA_shift(sk) \

  3314.   ((X509_POLICY_DATA *)sk_shift(      \

  3315.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3316. 

  3317. #define sk_X509_POLICY_DATA_push(sk, p)                             \

  3318.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3319.           CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3320. 

  3321. #define sk_X509_POLICY_DATA_pop(sk) \

  3322.   ((X509_POLICY_DATA *)sk_pop(      \

  3323.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3324. 

  3325. #define sk_X509_POLICY_DATA_dup(sk)      \

  3326.   ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \

  3327.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))

  3328. 

  3329. #define sk_X509_POLICY_DATA_sort(sk) \

  3330.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3331. 

  3332. #define sk_X509_POLICY_DATA_is_sorted(sk) \

  3333.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

  3334. 

  3335. #define sk_X509_POLICY_DATA_set_cmp_func(sk, comp)                           \

  3336.   ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b))         \

  3337.        sk_set_cmp_func(                                                      \

  3338.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk),         \

  3339.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a,  \

  3340.                                                 const X509_POLICY_DATA **b), \

  3341.                         comp)))

  3342. 

  3343. #define sk_X509_POLICY_DATA_deep_copy(sk, copy_func, free_func)             \

  3344.   ((STACK_OF(X509_POLICY_DATA) *)sk_deep_copy(                              \

  3345.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \

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

  3347.                    X509_POLICY_DATA *(*)(X509_POLICY_DATA *), copy_func),   \

  3348.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *),          \

  3349.                    free_func)))

  3350. 

  3351. /* X509_POLICY_NODE */

  3352. #define sk_X509_POLICY_NODE_new(comp)                 \

  3353.   ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \

  3354.       stack_cmp_func,                                 \

  3355.       int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))

  3356. 

  3357. #define sk_X509_POLICY_NODE_new_null() \

  3358.   ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())

  3359. 

  3360. #define sk_X509_POLICY_NODE_num(sk) \

  3361.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3362. 

  3363. #define sk_X509_POLICY_NODE_zero(sk) \

  3364.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));

  3365. 

  3366. #define sk_X509_POLICY_NODE_value(sk, i) \

  3367.   ((X509_POLICY_NODE *)sk_value(         \

  3368.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), (i)))

  3369. 

  3370. #define sk_X509_POLICY_NODE_set(sk, i, p)                            \

  3371.   ((X509_POLICY_NODE *)sk_set(                                       \

  3372.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \

  3373.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3374. 

  3375. #define sk_X509_POLICY_NODE_free(sk) \

  3376.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3377. 

  3378. #define sk_X509_POLICY_NODE_pop_free(sk, free_func)             \

  3379.   sk_pop_free(                                                  \

  3380.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3381.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))

  3382. 

  3383. #define sk_X509_POLICY_NODE_insert(sk, p, where)                      \

  3384.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3385.             CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))

  3386. 

  3387. #define sk_X509_POLICY_NODE_delete(sk, where) \

  3388.   ((X509_POLICY_NODE *)sk_delete(             \

  3389.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))

  3390. 

  3391. #define sk_X509_POLICY_NODE_delete_ptr(sk, p)                   \

  3392.   ((X509_POLICY_NODE *)sk_delete_ptr(                           \

  3393.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3394.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3395. 

  3396. #define sk_X509_POLICY_NODE_find(sk, out_index, p)                  \

  3397.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3398.           (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3399. 

  3400. #define sk_X509_POLICY_NODE_shift(sk) \

  3401.   ((X509_POLICY_NODE *)sk_shift(      \

  3402.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3403. 

  3404. #define sk_X509_POLICY_NODE_push(sk, p)                             \

  3405.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3406.           CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3407. 

  3408. #define sk_X509_POLICY_NODE_pop(sk) \

  3409.   ((X509_POLICY_NODE *)sk_pop(      \

  3410.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3411. 

  3412. #define sk_X509_POLICY_NODE_dup(sk)      \

  3413.   ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \

  3414.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))

  3415. 

  3416. #define sk_X509_POLICY_NODE_sort(sk) \

  3417.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3418. 

  3419. #define sk_X509_POLICY_NODE_is_sorted(sk) \

  3420.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

  3421. 

  3422. #define sk_X509_POLICY_NODE_set_cmp_func(sk, comp)                           \

  3423.   ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b))         \

  3424.        sk_set_cmp_func(                                                      \

  3425.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk),         \

  3426.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a,  \

  3427.                                                 const X509_POLICY_NODE **b), \

  3428.                         comp)))

  3429. 

  3430. #define sk_X509_POLICY_NODE_deep_copy(sk, copy_func, free_func)             \

  3431.   ((STACK_OF(X509_POLICY_NODE) *)sk_deep_copy(                              \

  3432.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \

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

  3434.                    X509_POLICY_NODE *(*)(X509_POLICY_NODE *), copy_func),   \

  3435.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *),          \

  3436.                    free_func)))

  3437. 

  3438. /* X509_PURPOSE */

  3439. #define sk_X509_PURPOSE_new(comp)                                              \

  3440.   ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST(                              \

  3441.       stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \

  3442.       comp)))

  3443. 

  3444. #define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null())

  3445. 

  3446. #define sk_X509_PURPOSE_num(sk) \

  3447.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3448. 

  3449. #define sk_X509_PURPOSE_zero(sk) \

  3450.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));

  3451. 

  3452. #define sk_X509_PURPOSE_value(sk, i) \

  3453.   ((X509_PURPOSE *)sk_value(         \

  3454.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))

  3455. 

  3456. #define sk_X509_PURPOSE_set(sk, i, p)                            \

  3457.   ((X509_PURPOSE *)sk_set(                                       \

  3458.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \

  3459.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3460. 

  3461. #define sk_X509_PURPOSE_free(sk) \

  3462.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3463. 

  3464. #define sk_X509_PURPOSE_pop_free(sk, free_func)             \

  3465.   sk_pop_free(                                              \

  3466.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3467.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))

  3468. 

  3469. #define sk_X509_PURPOSE_insert(sk, p, where)                      \

  3470.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3471.             CHECKED_CAST(void *, X509_PURPOSE *, p), (where))

  3472. 

  3473. #define sk_X509_PURPOSE_delete(sk, where) \

  3474.   ((X509_PURPOSE *)sk_delete(             \

  3475.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))

  3476. 

  3477. #define sk_X509_PURPOSE_delete_ptr(sk, p)                   \

  3478.   ((X509_PURPOSE *)sk_delete_ptr(                           \

  3479.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3480.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3481. 

  3482. #define sk_X509_PURPOSE_find(sk, out_index, p)                               \

  3483.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \

  3484.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3485. 

  3486. #define sk_X509_PURPOSE_shift(sk) \

  3487.   ((X509_PURPOSE *)sk_shift(      \

  3488.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3489. 

  3490. #define sk_X509_PURPOSE_push(sk, p)                             \

  3491.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3492.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3493. 

  3494. #define sk_X509_PURPOSE_pop(sk) \

  3495.   ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3496. 

  3497. #define sk_X509_PURPOSE_dup(sk)      \

  3498.   ((STACK_OF(X509_PURPOSE) *)sk_dup( \

  3499.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk)))

  3500. 

  3501. #define sk_X509_PURPOSE_sort(sk) \

  3502.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3503. 

  3504. #define sk_X509_PURPOSE_is_sorted(sk) \

  3505.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk))

  3506. 

  3507. #define sk_X509_PURPOSE_set_cmp_func(sk, comp)                               \

  3508.   ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \

  3509.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk),                  \

  3510.       CHECKED_CAST(stack_cmp_func,                                           \

  3511.                    int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b),  \

  3512.                    comp)))

  3513. 

  3514. #define sk_X509_PURPOSE_deep_copy(sk, copy_func, free_func)              \

  3515.   ((STACK_OF(X509_PURPOSE) *)sk_deep_copy(                               \

  3516.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk),  \

  3517.       CHECKED_CAST(void *(*)(void *), X509_PURPOSE *(*)(X509_PURPOSE *), \

  3518.                    copy_func),                                           \

  3519.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func)))

  3520. 

  3521. /* X509_REVOKED */

  3522. #define sk_X509_REVOKED_new(comp)                                              \

  3523.   ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST(                              \

  3524.       stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \

  3525.       comp)))

  3526. 

  3527. #define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null())

  3528. 

  3529. #define sk_X509_REVOKED_num(sk) \

  3530.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3531. 

  3532. #define sk_X509_REVOKED_zero(sk) \

  3533.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));

  3534. 

  3535. #define sk_X509_REVOKED_value(sk, i) \

  3536.   ((X509_REVOKED *)sk_value(         \

  3537.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))

  3538. 

  3539. #define sk_X509_REVOKED_set(sk, i, p)                            \

  3540.   ((X509_REVOKED *)sk_set(                                       \

  3541.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \

  3542.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3543. 

  3544. #define sk_X509_REVOKED_free(sk) \

  3545.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3546. 

  3547. #define sk_X509_REVOKED_pop_free(sk, free_func)             \

  3548.   sk_pop_free(                                              \

  3549.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3550.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))

  3551. 

  3552. #define sk_X509_REVOKED_insert(sk, p, where)                      \

  3553.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3554.             CHECKED_CAST(void *, X509_REVOKED *, p), (where))

  3555. 

  3556. #define sk_X509_REVOKED_delete(sk, where) \

  3557.   ((X509_REVOKED *)sk_delete(             \

  3558.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))

  3559. 

  3560. #define sk_X509_REVOKED_delete_ptr(sk, p)                   \

  3561.   ((X509_REVOKED *)sk_delete_ptr(                           \

  3562.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3563.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3564. 

  3565. #define sk_X509_REVOKED_find(sk, out_index, p)                               \

  3566.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \

  3567.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3568. 

  3569. #define sk_X509_REVOKED_shift(sk) \

  3570.   ((X509_REVOKED *)sk_shift(      \

  3571.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3572. 

  3573. #define sk_X509_REVOKED_push(sk, p)                             \

  3574.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3575.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3576. 

  3577. #define sk_X509_REVOKED_pop(sk) \

  3578.   ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3579. 

  3580. #define sk_X509_REVOKED_dup(sk)      \

  3581.   ((STACK_OF(X509_REVOKED) *)sk_dup( \

  3582.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk)))

  3583. 

  3584. #define sk_X509_REVOKED_sort(sk) \

  3585.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3586. 

  3587. #define sk_X509_REVOKED_is_sorted(sk) \

  3588.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk))

  3589. 

  3590. #define sk_X509_REVOKED_set_cmp_func(sk, comp)                               \

  3591.   ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \

  3592.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk),                  \

  3593.       CHECKED_CAST(stack_cmp_func,                                           \

  3594.                    int (*)(const X509_REVOKED **a, const X509_REVOKED **b),  \

  3595.                    comp)))

  3596. 

  3597. #define sk_X509_REVOKED_deep_copy(sk, copy_func, free_func)              \

  3598.   ((STACK_OF(X509_REVOKED) *)sk_deep_copy(                               \

  3599.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk),  \

  3600.       CHECKED_CAST(void *(*)(void *), X509_REVOKED *(*)(X509_REVOKED *), \

  3601.                    copy_func),                                           \

  3602.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func)))

  3603. 

  3604. /* X509_TRUST */

  3605. #define sk_X509_TRUST_new(comp)                                            \

  3606.   ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST(                            \

  3607.       stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \

  3608.       comp)))

  3609. 

  3610. #define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null())

  3611. 

  3612. #define sk_X509_TRUST_num(sk) \

  3613.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3614. 

  3615. #define sk_X509_TRUST_zero(sk) \

  3616.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));

  3617. 

  3618. #define sk_X509_TRUST_value(sk, i) \

  3619.   ((X509_TRUST *)sk_value(         \

  3620.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))

  3621. 

  3622. #define sk_X509_TRUST_set(sk, i, p)                                         \

  3623.   ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3624.                         (i), CHECKED_CAST(void *, X509_TRUST *, p)))

  3625. 

  3626. #define sk_X509_TRUST_free(sk) \

  3627.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3628. 

  3629. #define sk_X509_TRUST_pop_free(sk, free_func)             \

  3630.   sk_pop_free(                                            \

  3631.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3632.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))

  3633. 

  3634. #define sk_X509_TRUST_insert(sk, p, where)                      \

  3635.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3636.             CHECKED_CAST(void *, X509_TRUST *, p), (where))

  3637. 

  3638. #define sk_X509_TRUST_delete(sk, where)                                        \

  3639.   ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3640.                            (where)))

  3641. 

  3642. #define sk_X509_TRUST_delete_ptr(sk, p)                   \

  3643.   ((X509_TRUST *)sk_delete_ptr(                           \

  3644.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3645.       CHECKED_CAST(void *, X509_TRUST *, p)))

  3646. 

  3647. #define sk_X509_TRUST_find(sk, out_index, p)                               \

  3648.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \

  3649.           CHECKED_CAST(void *, X509_TRUST *, p))

  3650. 

  3651. #define sk_X509_TRUST_shift(sk) \

  3652.   ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3653. 

  3654. #define sk_X509_TRUST_push(sk, p)                             \

  3655.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3656.           CHECKED_CAST(void *, X509_TRUST *, p))

  3657. 

  3658. #define sk_X509_TRUST_pop(sk) \

  3659.   ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3660. 

  3661. #define sk_X509_TRUST_dup(sk)      \

  3662.   ((STACK_OF(X509_TRUST) *)sk_dup( \

  3663.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk)))

  3664. 

  3665. #define sk_X509_TRUST_sort(sk) \

  3666.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3667. 

  3668. #define sk_X509_TRUST_is_sorted(sk) \

  3669.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk))

  3670. 

  3671. #define sk_X509_TRUST_set_cmp_func(sk, comp)                             \

  3672.   ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \

  3673.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk),                \

  3674.       CHECKED_CAST(stack_cmp_func,                                       \

  3675.                    int (*)(const X509_TRUST **a, const X509_TRUST **b),  \

  3676.                    comp)))

  3677. 

  3678. #define sk_X509_TRUST_deep_copy(sk, copy_func, free_func)             \

  3679.   ((STACK_OF(X509_TRUST) *)sk_deep_copy(                              \

  3680.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), \

  3681.       CHECKED_CAST(void *(*)(void *), X509_TRUST *(*)(X509_TRUST *),  \

  3682.                    copy_func),                                        \

  3683.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func)))

  3684. 

  3685. /* X509_VERIFY_PARAM */

  3686. #define sk_X509_VERIFY_PARAM_new(comp)                                   \

  3687.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST(                   \

  3688.       stack_cmp_func,                                                    \

  3689.       int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \

  3690.       comp)))

  3691. 

  3692. #define sk_X509_VERIFY_PARAM_new_null() \

  3693.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())

  3694. 

  3695. #define sk_X509_VERIFY_PARAM_num(sk) \

  3696.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3697. 

  3698. #define sk_X509_VERIFY_PARAM_zero(sk) \

  3699.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));

  3700. 

  3701. #define sk_X509_VERIFY_PARAM_value(sk, i) \

  3702.   ((X509_VERIFY_PARAM *)sk_value(         \

  3703.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), (i)))

  3704. 

  3705. #define sk_X509_VERIFY_PARAM_set(sk, i, p)                            \

  3706.   ((X509_VERIFY_PARAM *)sk_set(                                       \

  3707.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \

  3708.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3709. 

  3710. #define sk_X509_VERIFY_PARAM_free(sk) \

  3711.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3712. 

  3713. #define sk_X509_VERIFY_PARAM_pop_free(sk, free_func)                        \

  3714.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),    \

  3715.               CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \

  3716.                            free_func))

  3717. 

  3718. #define sk_X509_VERIFY_PARAM_insert(sk, p, where)                      \

  3719.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3720.             CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))

  3721. 

  3722. #define sk_X509_VERIFY_PARAM_delete(sk, where) \

  3723.   ((X509_VERIFY_PARAM *)sk_delete(             \

  3724.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))

  3725. 

  3726. #define sk_X509_VERIFY_PARAM_delete_ptr(sk, p)                   \

  3727.   ((X509_VERIFY_PARAM *)sk_delete_ptr(                           \

  3728.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3729.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3730. 

  3731. #define sk_X509_VERIFY_PARAM_find(sk, out_index, p)                  \

  3732.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3733.           (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3734. 

  3735. #define sk_X509_VERIFY_PARAM_shift(sk) \

  3736.   ((X509_VERIFY_PARAM *)sk_shift(      \

  3737.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3738. 

  3739. #define sk_X509_VERIFY_PARAM_push(sk, p)                             \

  3740.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3741.           CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3742. 

  3743. #define sk_X509_VERIFY_PARAM_pop(sk) \

  3744.   ((X509_VERIFY_PARAM *)sk_pop(      \

  3745.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3746. 

  3747. #define sk_X509_VERIFY_PARAM_dup(sk)      \

  3748.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \

  3749.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3750. 

  3751. #define sk_X509_VERIFY_PARAM_sort(sk) \

  3752.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3753. 

  3754. #define sk_X509_VERIFY_PARAM_is_sorted(sk) \

  3755.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

  3756. 

  3757. #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp)                           \

  3758.   ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b))        \

  3759.        sk_set_cmp_func(                                                       \

  3760.            CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),         \

  3761.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a,  \

  3762.                                                 const X509_VERIFY_PARAM **b), \

  3763.                         comp)))

  3764. 

  3765. #define sk_X509_VERIFY_PARAM_deep_copy(sk, copy_func, free_func)             \

  3766.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_deep_copy(                              \

  3767.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \

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

  3769.                    X509_VERIFY_PARAM *(*)(X509_VERIFY_PARAM *), copy_func),  \

  3770.       CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *),          \

  3771.                    free_func)))

  3772. 

  3773. /* void */

  3774. #define sk_void_new(comp)                \

  3775.   ((STACK_OF(void)*)sk_new(CHECKED_CAST( \

  3776.       stack_cmp_func, int (*)(const void **a, const void **b), comp)))

  3777. 

  3778. #define sk_void_new_null() ((STACK_OF(void)*)sk_new_null())

  3779. 

  3780. #define sk_void_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3781. 

  3782. #define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk));

  3783. 

  3784. #define sk_void_value(sk, i) \

  3785.   ((void *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk), (i)))

  3786. 

  3787. #define sk_void_set(sk, i, p)                                       \

  3788.   ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (i), \

  3789.                   CHECKED_CAST(void *, void *, p)))

  3790. 

  3791. #define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3792. 

  3793. #define sk_void_pop_free(sk, free_func)                     \

  3794.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3795.               CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))

  3796. 

  3797. #define sk_void_insert(sk, p, where)                      \

  3798.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3799.             CHECKED_CAST(void *, void *, p), (where))

  3800. 

  3801. #define sk_void_delete(sk, where) \

  3802.   ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (where)))

  3803. 

  3804. #define sk_void_delete_ptr(sk, p)                                     \

  3805.   ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3806.                          CHECKED_CAST(void *, void *, p)))

  3807. 

  3808. #define sk_void_find(sk, out_index, p)                               \

  3809.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (out_index), \

  3810.           CHECKED_CAST(void *, void *, p))

  3811. 

  3812. #define sk_void_shift(sk) \

  3813.   ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3814. 

  3815. #define sk_void_push(sk, p)                             \

  3816.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3817.           CHECKED_CAST(void *, void *, p))

  3818. 

  3819. #define sk_void_pop(sk) \

  3820.   ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3821. 

  3822. #define sk_void_dup(sk) \

  3823.   ((STACK_OF(void)*)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk)))

  3824. 

  3825. #define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3826. 

  3827. #define sk_void_is_sorted(sk) \

  3828.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(void) *, sk))

  3829. 

  3830. #define sk_void_set_cmp_func(sk, comp)                                      \

  3831.   ((int (*)(const void **a, const void **b))sk_set_cmp_func(                \

  3832.       CHECKED_CAST(_STACK *, STACK_OF(void)*, sk),                          \

  3833.       CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \

  3834.                    comp)))

  3835. 

  3836. #define sk_void_deep_copy(sk, copy_func, free_func)                  \

  3837.   ((STACK_OF(void)*)sk_deep_copy(                                    \

  3838.       CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk),      \

  3839.       CHECKED_CAST(void *(*)(void *), void *(*)(void *), copy_func), \

  3840.       CHECKED_CAST(void (*)(void *), void (*)(void *), free_func)))

  3841. 

  3842. /* SRTP_PROTECTION_PROFILE */

  3843. #define sk_SRTP_PROTECTION_PROFILE_new(comp)                            \

  3844.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST(            \

  3845.       stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a,  \

  3846.                               const const SRTP_PROTECTION_PROFILE **b), \

  3847.       comp)))

  3848. 

  3849. #define sk_SRTP_PROTECTION_PROFILE_new_null() \

  3850.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())

  3851. 

  3852. #define sk_SRTP_PROTECTION_PROFILE_num(sk) \

  3853.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3854. 

  3855. #define sk_SRTP_PROTECTION_PROFILE_zero(sk) \

  3856.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));

  3857. 

  3858. #define sk_SRTP_PROTECTION_PROFILE_value(sk, i)                              \

  3859.   ((const SRTP_PROTECTION_PROFILE *)sk_value(                                \

  3860.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3861.       (i)))

  3862. 

  3863. #define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p)                            \

  3864.   ((const SRTP_PROTECTION_PROFILE *)sk_set(                                 \

  3865.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \

  3866.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3867. 

  3868. #define sk_SRTP_PROTECTION_PROFILE_free(sk) \

  3869.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3870. 

  3871. #define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func)             \

  3872.   sk_pop_free(                                                         \

  3873.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

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

  3875.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func))

  3876. 

  3877. #define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where)                      \

  3878.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3879.             CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where))

  3880. 

  3881. #define sk_SRTP_PROTECTION_PROFILE_delete(sk, where)                   \

  3882.   ((const SRTP_PROTECTION_PROFILE *)sk_delete(                         \

  3883.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3884.       (where)))

  3885. 

  3886. #define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p)                   \

  3887.   ((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr(                     \

  3888.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3889.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3890. 

  3891. #define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p)                  \

  3892.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3893.           (out_index),                                                     \

  3894.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3895. 

  3896. #define sk_SRTP_PROTECTION_PROFILE_shift(sk)  \

  3897.   ((const SRTP_PROTECTION_PROFILE *)sk_shift( \

  3898.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3899. 

  3900. #define sk_SRTP_PROTECTION_PROFILE_push(sk, p)                             \

  3901.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3902.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3903. 

  3904. #define sk_SRTP_PROTECTION_PROFILE_pop(sk)  \

  3905.   ((const SRTP_PROTECTION_PROFILE *)sk_pop( \

  3906.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3907. 

  3908. #define sk_SRTP_PROTECTION_PROFILE_dup(sk)      \

  3909.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup( \

  3910.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3911. 

  3912. #define sk_SRTP_PROTECTION_PROFILE_sort(sk) \

  3913.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3914. 

  3915. #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \

  3916.   sk_is_sorted(                                  \

  3917.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3918. 

  3919. #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp)                   \

  3920.   ((int (*)(const SRTP_PROTECTION_PROFILE **a,                              \

  3921.             const SRTP_PROTECTION_PROFILE **b))                             \

  3922.        sk_set_cmp_func(                                                     \

  3923.            CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3924.            CHECKED_CAST(stack_cmp_func,                                     \

  3925.                         int (*)(const SRTP_PROTECTION_PROFILE **a,          \

  3926.                                 const SRTP_PROTECTION_PROFILE **b),         \

  3927.                         comp)))

  3928. 

  3929. #define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copy_func, free_func)        \

  3930.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_deep_copy(                         \

  3931.       CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \

  3932.                    sk),                                                       \

  3933.       CHECKED_CAST(void *(*)(void *), const SRTP_PROTECTION_PROFILE *(*)(     \

  3934.                                           const SRTP_PROTECTION_PROFILE *),   \

  3935.                    copy_func),                                                \

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

  3937.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func)))

  3938. 

  3939. /* SSL_CIPHER */

  3940. #define sk_SSL_CIPHER_new(comp)                 \

  3941.   ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \

  3942.       stack_cmp_func,                           \

  3943.       int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp)))

  3944. 

  3945. #define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null())

  3946. 

  3947. #define sk_SSL_CIPHER_num(sk) \

  3948.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3949. 

  3950. #define sk_SSL_CIPHER_zero(sk) \

  3951.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));

  3952. 

  3953. #define sk_SSL_CIPHER_value(sk, i) \

  3954.   ((const SSL_CIPHER *)sk_value(   \

  3955.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))

  3956. 

  3957. #define sk_SSL_CIPHER_set(sk, i, p)                            \

  3958.   ((const SSL_CIPHER *)sk_set(                                 \

  3959.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \

  3960.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3961. 

  3962. #define sk_SSL_CIPHER_free(sk) \

  3963.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3964. 

  3965. #define sk_SSL_CIPHER_pop_free(sk, free_func)             \

  3966.   sk_pop_free(                                            \

  3967.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3968.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func))

  3969. 

  3970. #define sk_SSL_CIPHER_insert(sk, p, where)                      \

  3971.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3972.             CHECKED_CAST(void *, const SSL_CIPHER *, p), (where))

  3973. 

  3974. #define sk_SSL_CIPHER_delete(sk, where) \

  3975.   ((const SSL_CIPHER *)sk_delete(       \

  3976.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where)))

  3977. 

  3978. #define sk_SSL_CIPHER_delete_ptr(sk, p)                   \

  3979.   ((const SSL_CIPHER *)sk_delete_ptr(                     \

  3980.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3981.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3982. 

  3983. #define sk_SSL_CIPHER_find(sk, out_index, p)                               \

  3984.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \

  3985.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3986. 

  3987. #define sk_SSL_CIPHER_shift(sk)  \

  3988.   ((const SSL_CIPHER *)sk_shift( \

  3989.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3990. 

  3991. #define sk_SSL_CIPHER_push(sk, p)                             \

  3992.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3993.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3994. 

  3995. #define sk_SSL_CIPHER_pop(sk)  \

  3996.   ((const SSL_CIPHER *)sk_pop( \

  3997.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3998. 

  3999. #define sk_SSL_CIPHER_dup(sk)      \

  4000.   ((STACK_OF(SSL_CIPHER) *)sk_dup( \

  4001.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk)))

  4002. 

  4003. #define sk_SSL_CIPHER_sort(sk) \

  4004.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  4005. 

  4006. #define sk_SSL_CIPHER_is_sorted(sk) \

  4007.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk))

  4008. 

  4009. #define sk_SSL_CIPHER_set_cmp_func(sk, comp)                             \

  4010.   ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \

  4011.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk),                \

  4012.       CHECKED_CAST(stack_cmp_func,                                       \

  4013.                    int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b),  \

  4014.                    comp)))

  4015. 

  4016. #define sk_SSL_CIPHER_deep_copy(sk, copy_func, free_func)                 \

  4017.   ((STACK_OF(SSL_CIPHER) *)sk_deep_copy(                                  \

  4018.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk),     \

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

  4020.                    const SSL_CIPHER *(*)(const SSL_CIPHER *), copy_func), \

  4021.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *),        \

  4022.                    free_func)))

  4023. 

  4024. /* OPENSSL_STRING */

  4025. #define sk_OPENSSL_STRING_new(comp)                 \

  4026.   ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \

  4027.       stack_cmp_func,                               \

  4028.       int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))

  4029. 

  4030. #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())

  4031. 

  4032. #define sk_OPENSSL_STRING_num(sk) \

  4033.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  4034. 

  4035. #define sk_OPENSSL_STRING_zero(sk) \

  4036.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));

  4037. 

  4038. #define sk_OPENSSL_STRING_value(sk, i) \

  4039.   ((OPENSSL_STRING)sk_value(           \

  4040.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk), (i)))

  4041. 

  4042. #define sk_OPENSSL_STRING_set(sk, i, p)                            \

  4043.   ((OPENSSL_STRING)sk_set(                                         \

  4044.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \

  4045.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  4046. 

  4047. #define sk_OPENSSL_STRING_free(sk) \

  4048.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  4049. 

  4050. #define sk_OPENSSL_STRING_pop_free(sk, free_func)             \

  4051.   sk_pop_free(                                                \

  4052.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  4053.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))

  4054. 

  4055. #define sk_OPENSSL_STRING_insert(sk, p, where)                      \

  4056.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  4057.             CHECKED_CAST(void *, OPENSSL_STRING, p), (where))

  4058. 

  4059. #define sk_OPENSSL_STRING_delete(sk, where) \

  4060.   ((OPENSSL_STRING)sk_delete(               \

  4061.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))

  4062. 

  4063. #define sk_OPENSSL_STRING_delete_ptr(sk, p)                   \

  4064.   ((OPENSSL_STRING)sk_delete_ptr(                             \

  4065.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  4066.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  4067. 

  4068. #define sk_OPENSSL_STRING_find(sk, out_index, p)                               \

  4069.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \

  4070.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  4071. 

  4072. #define sk_OPENSSL_STRING_shift(sk) \

  4073.   ((OPENSSL_STRING)sk_shift(        \

  4074.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  4075. 

  4076. #define sk_OPENSSL_STRING_push(sk, p)                             \

  4077.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  4078.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  4079. 

  4080. #define sk_OPENSSL_STRING_pop(sk) \

  4081.   ((OPENSSL_STRING)sk_pop(        \

  4082.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  4083. 

  4084. #define sk_OPENSSL_STRING_dup(sk)      \

  4085.   ((STACK_OF(OPENSSL_STRING) *)sk_dup( \

  4086.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))

  4087. 

  4088. #define sk_OPENSSL_STRING_sort(sk) \

  4089.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  4090. 

  4091. #define sk_OPENSSL_STRING_is_sorted(sk) \

  4092.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

  4093. 

  4094. #define sk_OPENSSL_STRING_set_cmp_func(sk, comp)                           \

  4095.   ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b))           \

  4096.        sk_set_cmp_func(                                                    \

  4097.            CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk),         \

  4098.            CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a,  \

  4099.                                                 const OPENSSL_STRING **b), \

  4100.                         comp)))

  4101. 

  4102. #define sk_OPENSSL_STRING_deep_copy(sk, copy_func, free_func)             \

  4103.   ((STACK_OF(OPENSSL_STRING) *)sk_deep_copy(                              \

  4104.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \

  4105.       CHECKED_CAST(void *(*)(void *), OPENSSL_STRING (*)(OPENSSL_STRING), \

  4106.                    copy_func),                                            \

  4107.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func)))

  4108. 

  4109. /* OPENSSL_BLOCK */

  4110. #define sk_OPENSSL_BLOCK_new(comp)                                             \

  4111.   ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_CAST(                             \

  4112.       stack_cmp_func, int (*)(const OPENSSL_BLOCK *a, const OPENSSL_BLOCK *b), \

  4113.       comp)))

  4114. 

  4115. #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())

  4116. 

  4117. #define sk_OPENSSL_BLOCK_num(sk) \

  4118.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  4119. 

  4120. #define sk_OPENSSL_BLOCK_zero(sk) \

  4121.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk));

  4122. 

  4123. #define sk_OPENSSL_BLOCK_value(sk, i) \

  4124.   ((OPENSSL_BLOCK)sk_value(           \

  4125.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), (i)))

  4126. 

  4127. #define sk_OPENSSL_BLOCK_set(sk, i, p)                            \

  4128.   ((OPENSSL_BLOCK)sk_set(                                         \

  4129.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (i), \

  4130.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  4131. 

  4132. #define sk_OPENSSL_BLOCK_free(sk) \

  4133.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  4134. 

  4135. #define sk_OPENSSL_BLOCK_pop_free(sk, free_func)             \

  4136.   sk_pop_free(                                               \

  4137.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  4138.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func))

  4139. 

  4140. #define sk_OPENSSL_BLOCK_insert(sk, p, where)                      \

  4141.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  4142.             CHECKED_CAST(void *, OPENSSL_BLOCK, p), (where))

  4143. 

  4144. #define sk_OPENSSL_BLOCK_delete(sk, where) \

  4145.   ((OPENSSL_BLOCK)sk_delete(               \

  4146.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (where)))

  4147. 

  4148. #define sk_OPENSSL_BLOCK_delete_ptr(sk, p)                   \

  4149.   ((OPENSSL_BLOCK)sk_delete_ptr(                             \

  4150.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  4151.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  4152. 

  4153. #define sk_OPENSSL_BLOCK_find(sk, out_index, p)                               \

  4154.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (out_index), \

  4155.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  4156. 

  4157. #define sk_OPENSSL_BLOCK_shift(sk) \

  4158.   ((OPENSSL_BLOCK)sk_shift(        \

  4159.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  4160. 

  4161. #define sk_OPENSSL_BLOCK_push(sk, p)                             \

  4162.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  4163.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  4164. 

  4165. #define sk_OPENSSL_BLOCK_pop(sk) \

  4166.   ((OPENSSL_BLOCK)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  4167. 

  4168. #define sk_OPENSSL_BLOCK_dup(sk)      \

  4169.   ((STACK_OF(OPENSSL_BLOCK) *)sk_dup( \

  4170.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)))

  4171. 

  4172. #define sk_OPENSSL_BLOCK_sort(sk) \

  4173.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  4174. 

  4175. #define sk_OPENSSL_BLOCK_is_sorted(sk) \

  4176.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk))

  4177. 

  4178. #define sk_OPENSSL_BLOCK_set_cmp_func(sk, comp)                                \

  4179.   ((int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b))sk_set_cmp_func( \

  4180.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk),                   \

  4181.       CHECKED_CAST(stack_cmp_func,                                             \

  4182.                    int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b),  \

  4183.                    comp)))

  4184. 

  4185. #define sk_OPENSSL_BLOCK_deep_copy(sk, copy_func, free_func)             \

  4186.   ((STACK_OF(OPENSSL_BLOCK) *)sk_deep_copy(                              \

  4187.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), \

  4188.       CHECKED_CAST(void *(*)(void *), OPENSSL_BLOCK (*)(OPENSSL_BLOCK),  \

  4189.                    copy_func),                                           \

  4190.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func)))