kris
/
boringssl
1
0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
3902 Incheckningar
12 Grenar
38 MiB
 
 
 
 
 
 
Träd: 4c341d0299
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '4c341d0299'
${ noResults }
boringssl/include/openssl/stack_macros.h

3988 rader
183 KiB
Rå Blame Historik 

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

  2.  *

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

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

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

  6.  *

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

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

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

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

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

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

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

  14. 

  15. #if !defined(IN_STACK_H)

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

  17. #endif

  18. 

  19. /* ACCESS_DESCRIPTION */

  20. #define sk_ACCESS_DESCRIPTION_new(comp)                                    \

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

  22.       stack_cmp_func,                                                      \

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

  24.       comp)))

  25. 

  26. #define sk_ACCESS_DESCRIPTION_new_null() \

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

  28. 

  29. #define sk_ACCESS_DESCRIPTION_num(sk) \

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

  31. 

  32. #define sk_ACCESS_DESCRIPTION_zero(sk) \

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

  34. 

  35. #define sk_ACCESS_DESCRIPTION_value(sk, i)                                    \

  36.   ((ACCESS_DESCRIPTION *)sk_value(                                            \

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

  38.       (i)))

  39. 

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

  41.   ((ACCESS_DESCRIPTION *)sk_set(                                       \

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

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

  44. 

  45. #define sk_ACCESS_DESCRIPTION_free(sk) \

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

  47. 

  48. #define sk_ACCESS_DESCRIPTION_pop_free(sk, free_func)                        \

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

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

  51.                            free_func))

  52. 

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

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

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

  56. 

  57. #define sk_ACCESS_DESCRIPTION_delete(sk, where) \

  58.   ((ACCESS_DESCRIPTION *)sk_delete(             \

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

  60. 

  61. #define sk_ACCESS_DESCRIPTION_delete_ptr(sk, p)                   \

  62.   ((ACCESS_DESCRIPTION *)sk_delete_ptr(                           \

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

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

  65. 

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

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

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

  69. 

  70. #define sk_ACCESS_DESCRIPTION_shift(sk) \

  71.   ((ACCESS_DESCRIPTION *)sk_shift(      \

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

  73. 

  74. #define sk_ACCESS_DESCRIPTION_push(sk, p)                             \

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

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

  77. 

  78. #define sk_ACCESS_DESCRIPTION_pop(sk) \

  79.   ((ACCESS_DESCRIPTION *)sk_pop(      \

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

  81. 

  82. #define sk_ACCESS_DESCRIPTION_dup(sk)      \

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

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

  85. 

  86. #define sk_ACCESS_DESCRIPTION_sort(sk) \

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

  88. 

  89. #define sk_ACCESS_DESCRIPTION_is_sorted(sk) \

  90.   sk_is_sorted(                             \

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

  92. 

  93. #define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp)                           \

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

  95.        sk_set_cmp_func(                                                        \

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

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

  98.                                                 const ACCESS_DESCRIPTION **b), \

  99.                         comp)))

  100. 

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

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

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

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

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

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

  107.                    free_func)))

  108. 

  109. /* ASN1_ADB_TABLE */

  110. #define sk_ASN1_ADB_TABLE_new(comp)                 \

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

  112.       stack_cmp_func,                               \

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

  114. 

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

  116. 

  117. #define sk_ASN1_ADB_TABLE_num(sk) \

  118.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))

  119. 

  120. #define sk_ASN1_ADB_TABLE_zero(sk) \

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

  122. 

  123. #define sk_ASN1_ADB_TABLE_value(sk, i)                                    \

  124.   ((ASN1_ADB_TABLE *)sk_value(                                            \

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

  126.       (i)))

  127. 

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

  129.   ((ASN1_ADB_TABLE *)sk_set(                                       \

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

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

  132. 

  133. #define sk_ASN1_ADB_TABLE_free(sk) \

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

  135. 

  136. #define sk_ASN1_ADB_TABLE_pop_free(sk, free_func)             \

  137.   sk_pop_free(                                                \

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

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

  140. 

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

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

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

  144. 

  145. #define sk_ASN1_ADB_TABLE_delete(sk, where) \

  146.   ((ASN1_ADB_TABLE *)sk_delete(             \

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

  148. 

  149. #define sk_ASN1_ADB_TABLE_delete_ptr(sk, p)                   \

  150.   ((ASN1_ADB_TABLE *)sk_delete_ptr(                           \

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

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

  153. 

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

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

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

  157. 

  158. #define sk_ASN1_ADB_TABLE_shift(sk) \

  159.   ((ASN1_ADB_TABLE *)sk_shift(      \

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

  161. 

  162. #define sk_ASN1_ADB_TABLE_push(sk, p)                             \

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

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

  165. 

  166. #define sk_ASN1_ADB_TABLE_pop(sk) \

  167.   ((ASN1_ADB_TABLE *)sk_pop(      \

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

  169. 

  170. #define sk_ASN1_ADB_TABLE_dup(sk)      \

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

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

  173. 

  174. #define sk_ASN1_ADB_TABLE_sort(sk) \

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

  176. 

  177. #define sk_ASN1_ADB_TABLE_is_sorted(sk) \

  178.   sk_is_sorted(                         \

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

  180. 

  181. #define sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp)                           \

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

  183.        sk_set_cmp_func(                                                    \

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

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

  186.                                                 const ASN1_ADB_TABLE **b), \

  187.                         comp)))

  188. 

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

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

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

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

  193.                    copy_func),                                               \

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

  195. 

  196. /* ASN1_GENERALSTRING */

  197. #define sk_ASN1_GENERALSTRING_new(comp)                                    \

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

  199.       stack_cmp_func,                                                      \

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

  201.       comp)))

  202. 

  203. #define sk_ASN1_GENERALSTRING_new_null() \

  204.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())

  205. 

  206. #define sk_ASN1_GENERALSTRING_num(sk) \

  207.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))

  208. 

  209. #define sk_ASN1_GENERALSTRING_zero(sk) \

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

  211. 

  212. #define sk_ASN1_GENERALSTRING_value(sk, i)                                    \

  213.   ((ASN1_GENERALSTRING *)sk_value(                                            \

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

  215.       (i)))

  216. 

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

  218.   ((ASN1_GENERALSTRING *)sk_set(                                       \

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

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

  221. 

  222. #define sk_ASN1_GENERALSTRING_free(sk) \

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

  224. 

  225. #define sk_ASN1_GENERALSTRING_pop_free(sk, free_func)                        \

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

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

  228.                            free_func))

  229. 

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

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

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

  233. 

  234. #define sk_ASN1_GENERALSTRING_delete(sk, where) \

  235.   ((ASN1_GENERALSTRING *)sk_delete(             \

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

  237. 

  238. #define sk_ASN1_GENERALSTRING_delete_ptr(sk, p)                   \

  239.   ((ASN1_GENERALSTRING *)sk_delete_ptr(                           \

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

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

  242. 

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

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

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

  246. 

  247. #define sk_ASN1_GENERALSTRING_shift(sk) \

  248.   ((ASN1_GENERALSTRING *)sk_shift(      \

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

  250. 

  251. #define sk_ASN1_GENERALSTRING_push(sk, p)                             \

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

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

  254. 

  255. #define sk_ASN1_GENERALSTRING_pop(sk) \

  256.   ((ASN1_GENERALSTRING *)sk_pop(      \

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

  258. 

  259. #define sk_ASN1_GENERALSTRING_dup(sk)      \

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

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

  262. 

  263. #define sk_ASN1_GENERALSTRING_sort(sk) \

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

  265. 

  266. #define sk_ASN1_GENERALSTRING_is_sorted(sk) \

  267.   sk_is_sorted(                             \

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

  269. 

  270. #define sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp)                           \

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

  272.        sk_set_cmp_func(                                                        \

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

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

  275.                                                 const ASN1_GENERALSTRING **b), \

  276.                         comp)))

  277. 

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

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

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

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

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

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

  284.                    free_func)))

  285. 

  286. /* ASN1_INTEGER */

  287. #define sk_ASN1_INTEGER_new(comp)                                              \

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

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

  290.       comp)))

  291. 

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

  293. 

  294. #define sk_ASN1_INTEGER_num(sk) \

  295.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk))

  296. 

  297. #define sk_ASN1_INTEGER_zero(sk) \

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

  299. 

  300. #define sk_ASN1_INTEGER_value(sk, i) \

  301.   ((ASN1_INTEGER *)sk_value(         \

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

  303. 

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

  305.   ((ASN1_INTEGER *)sk_set(                                       \

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

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

  308. 

  309. #define sk_ASN1_INTEGER_free(sk) \

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

  311. 

  312. #define sk_ASN1_INTEGER_pop_free(sk, free_func)             \

  313.   sk_pop_free(                                              \

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

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

  316. 

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

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

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

  320. 

  321. #define sk_ASN1_INTEGER_delete(sk, where) \

  322.   ((ASN1_INTEGER *)sk_delete(             \

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

  324. 

  325. #define sk_ASN1_INTEGER_delete_ptr(sk, p)                   \

  326.   ((ASN1_INTEGER *)sk_delete_ptr(                           \

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

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

  329. 

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

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

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

  333. 

  334. #define sk_ASN1_INTEGER_shift(sk) \

  335.   ((ASN1_INTEGER *)sk_shift(      \

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

  337. 

  338. #define sk_ASN1_INTEGER_push(sk, p)                             \

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

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

  341. 

  342. #define sk_ASN1_INTEGER_pop(sk) \

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

  344. 

  345. #define sk_ASN1_INTEGER_dup(sk)      \

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

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

  348. 

  349. #define sk_ASN1_INTEGER_sort(sk) \

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

  351. 

  352. #define sk_ASN1_INTEGER_is_sorted(sk) \

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

  354. 

  355. #define sk_ASN1_INTEGER_set_cmp_func(sk, comp)                               \

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

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

  358.       CHECKED_CAST(stack_cmp_func,                                           \

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

  360.                    comp)))

  361. 

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

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

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

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

  366.                    copy_func),                                           \

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

  368. 

  369. /* ASN1_OBJECT */

  370. #define sk_ASN1_OBJECT_new(comp)                                             \

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

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

  373.       comp)))

  374. 

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

  376. 

  377. #define sk_ASN1_OBJECT_num(sk) \

  378.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk))

  379. 

  380. #define sk_ASN1_OBJECT_zero(sk) \

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

  382. 

  383. #define sk_ASN1_OBJECT_value(sk, i) \

  384.   ((ASN1_OBJECT *)sk_value(         \

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

  386. 

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

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

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

  390. 

  391. #define sk_ASN1_OBJECT_free(sk) \

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

  393. 

  394. #define sk_ASN1_OBJECT_pop_free(sk, free_func)             \

  395.   sk_pop_free(                                             \

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

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

  398. 

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

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

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

  402. 

  403. #define sk_ASN1_OBJECT_delete(sk, where) \

  404.   ((ASN1_OBJECT *)sk_delete(             \

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

  406. 

  407. #define sk_ASN1_OBJECT_delete_ptr(sk, p)                   \

  408.   ((ASN1_OBJECT *)sk_delete_ptr(                           \

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

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

  411. 

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

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

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

  415. 

  416. #define sk_ASN1_OBJECT_shift(sk) \

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

  418. 

  419. #define sk_ASN1_OBJECT_push(sk, p)                             \

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

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

  422. 

  423. #define sk_ASN1_OBJECT_pop(sk) \

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

  425. 

  426. #define sk_ASN1_OBJECT_dup(sk)      \

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

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

  429. 

  430. #define sk_ASN1_OBJECT_sort(sk) \

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

  432. 

  433. #define sk_ASN1_OBJECT_is_sorted(sk) \

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

  435. 

  436. #define sk_ASN1_OBJECT_set_cmp_func(sk, comp)                              \

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

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

  439.       CHECKED_CAST(stack_cmp_func,                                         \

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

  441.                    comp)))

  442. 

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

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

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

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

  447.                    copy_func),                                         \

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

  449. 

  450. /* ASN1_STRING_TABLE */

  451. #define sk_ASN1_STRING_TABLE_new(comp)                                   \

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

  453.       stack_cmp_func,                                                    \

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

  455.       comp)))

  456. 

  457. #define sk_ASN1_STRING_TABLE_new_null() \

  458.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())

  459. 

  460. #define sk_ASN1_STRING_TABLE_num(sk) \

  461.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))

  462. 

  463. #define sk_ASN1_STRING_TABLE_zero(sk) \

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

  465. 

  466. #define sk_ASN1_STRING_TABLE_value(sk, i)                                    \

  467.   ((ASN1_STRING_TABLE *)sk_value(                                            \

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

  469.       (i)))

  470. 

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

  472.   ((ASN1_STRING_TABLE *)sk_set(                                       \

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

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

  475. 

  476. #define sk_ASN1_STRING_TABLE_free(sk) \

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

  478. 

  479. #define sk_ASN1_STRING_TABLE_pop_free(sk, free_func)                        \

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

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

  482.                            free_func))

  483. 

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

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

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

  487. 

  488. #define sk_ASN1_STRING_TABLE_delete(sk, where) \

  489.   ((ASN1_STRING_TABLE *)sk_delete(             \

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

  491. 

  492. #define sk_ASN1_STRING_TABLE_delete_ptr(sk, p)                   \

  493.   ((ASN1_STRING_TABLE *)sk_delete_ptr(                           \

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

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

  496. 

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

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

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

  500. 

  501. #define sk_ASN1_STRING_TABLE_shift(sk) \

  502.   ((ASN1_STRING_TABLE *)sk_shift(      \

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

  504. 

  505. #define sk_ASN1_STRING_TABLE_push(sk, p)                             \

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

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

  508. 

  509. #define sk_ASN1_STRING_TABLE_pop(sk) \

  510.   ((ASN1_STRING_TABLE *)sk_pop(      \

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

  512. 

  513. #define sk_ASN1_STRING_TABLE_dup(sk)      \

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

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

  516. 

  517. #define sk_ASN1_STRING_TABLE_sort(sk) \

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

  519. 

  520. #define sk_ASN1_STRING_TABLE_is_sorted(sk) \

  521.   sk_is_sorted(                            \

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

  523. 

  524. #define sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp)                           \

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

  526.        sk_set_cmp_func(                                                       \

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

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

  529.                                                 const ASN1_STRING_TABLE **b), \

  530.                         comp)))

  531. 

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

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

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

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

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

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

  538.                    free_func)))

  539. 

  540. /* ASN1_TYPE */

  541. #define sk_ASN1_TYPE_new(comp)     \

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

  543.       CHECKED_CAST(stack_cmp_func, \

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

  545. 

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

  547. 

  548. #define sk_ASN1_TYPE_num(sk) \

  549.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk))

  550. 

  551. #define sk_ASN1_TYPE_zero(sk) \

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

  553. 

  554. #define sk_ASN1_TYPE_value(sk, i) \

  555.   ((ASN1_TYPE *)sk_value(         \

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

  557. 

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

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

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

  561. 

  562. #define sk_ASN1_TYPE_free(sk) \

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

  564. 

  565. #define sk_ASN1_TYPE_pop_free(sk, free_func)             \

  566.   sk_pop_free(                                           \

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

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

  569. 

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

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

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

  573. 

  574. #define sk_ASN1_TYPE_delete(sk, where)                                       \

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

  576.                           (where)))

  577. 

  578. #define sk_ASN1_TYPE_delete_ptr(sk, p)                   \

  579.   ((ASN1_TYPE *)sk_delete_ptr(                           \

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

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

  582. 

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

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

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

  586. 

  587. #define sk_ASN1_TYPE_shift(sk) \

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

  589. 

  590. #define sk_ASN1_TYPE_push(sk, p)                             \

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

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

  593. 

  594. #define sk_ASN1_TYPE_pop(sk) \

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

  596. 

  597. #define sk_ASN1_TYPE_dup(sk)      \

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

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

  600. 

  601. #define sk_ASN1_TYPE_sort(sk) \

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

  603. 

  604. #define sk_ASN1_TYPE_is_sorted(sk) \

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

  606. 

  607. #define sk_ASN1_TYPE_set_cmp_func(sk, comp)                            \

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

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

  610.       CHECKED_CAST(stack_cmp_func,                                     \

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

  612. 

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

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

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

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

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

  618. 

  619. /* ASN1_VALUE */

  620. #define sk_ASN1_VALUE_new(comp)                                            \

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

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

  623.       comp)))

  624. 

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

  626. 

  627. #define sk_ASN1_VALUE_num(sk) \

  628.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk))

  629. 

  630. #define sk_ASN1_VALUE_zero(sk) \

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

  632. 

  633. #define sk_ASN1_VALUE_value(sk, i) \

  634.   ((ASN1_VALUE *)sk_value(         \

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

  636. 

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

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

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

  640. 

  641. #define sk_ASN1_VALUE_free(sk) \

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

  643. 

  644. #define sk_ASN1_VALUE_pop_free(sk, free_func)             \

  645.   sk_pop_free(                                            \

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

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

  648. 

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

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

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

  652. 

  653. #define sk_ASN1_VALUE_delete(sk, where)                                        \

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

  655.                            (where)))

  656. 

  657. #define sk_ASN1_VALUE_delete_ptr(sk, p)                   \

  658.   ((ASN1_VALUE *)sk_delete_ptr(                           \

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

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

  661. 

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

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

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

  665. 

  666. #define sk_ASN1_VALUE_shift(sk) \

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

  668. 

  669. #define sk_ASN1_VALUE_push(sk, p)                             \

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

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

  672. 

  673. #define sk_ASN1_VALUE_pop(sk) \

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

  675. 

  676. #define sk_ASN1_VALUE_dup(sk)      \

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

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

  679. 

  680. #define sk_ASN1_VALUE_sort(sk) \

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

  682. 

  683. #define sk_ASN1_VALUE_is_sorted(sk) \

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

  685. 

  686. #define sk_ASN1_VALUE_set_cmp_func(sk, comp)                             \

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

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

  689.       CHECKED_CAST(stack_cmp_func,                                       \

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

  691.                    comp)))

  692. 

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

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

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

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

  697.                    copy_func),                                        \

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

  699. 

  700. /* BIO */

  701. #define sk_BIO_new(comp)                 \

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

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

  704. 

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

  706. 

  707. #define sk_BIO_num(sk) \

  708.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk))

  709. 

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

  711. 

  712. #define sk_BIO_value(sk, i)                                                 \

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

  714.                    (i)))

  715. 

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

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

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

  719. 

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

  721. 

  722. #define sk_BIO_pop_free(sk, free_func)                     \

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

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

  725. 

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

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

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

  729. 

  730. #define sk_BIO_delete(sk, where) \

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

  732. 

  733. #define sk_BIO_delete_ptr(sk, p)                                     \

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

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

  736. 

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

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

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

  740. 

  741. #define sk_BIO_shift(sk) \

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

  743. 

  744. #define sk_BIO_push(sk, p)                             \

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

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

  747. 

  748. #define sk_BIO_pop(sk) \

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

  750. 

  751. #define sk_BIO_dup(sk)      \

  752.   ((STACK_OF(BIO) *)sk_dup( \

  753.       CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk)))

  754. 

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

  756. 

  757. #define sk_BIO_is_sorted(sk) \

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

  759. 

  760. #define sk_BIO_set_cmp_func(sk, comp)                                     \

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

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

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

  764.                    comp)))

  765. 

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

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

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

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

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

  771. 

  772. /* BY_DIR_ENTRY */

  773. #define sk_BY_DIR_ENTRY_new(comp)                                              \

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

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

  776.       comp)))

  777. 

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

  779. 

  780. #define sk_BY_DIR_ENTRY_num(sk) \

  781.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))

  782. 

  783. #define sk_BY_DIR_ENTRY_zero(sk) \

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

  785. 

  786. #define sk_BY_DIR_ENTRY_value(sk, i) \

  787.   ((BY_DIR_ENTRY *)sk_value(         \

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

  789. 

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

  791.   ((BY_DIR_ENTRY *)sk_set(                                       \

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

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

  794. 

  795. #define sk_BY_DIR_ENTRY_free(sk) \

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

  797. 

  798. #define sk_BY_DIR_ENTRY_pop_free(sk, free_func)             \

  799.   sk_pop_free(                                              \

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

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

  802. 

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

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

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

  806. 

  807. #define sk_BY_DIR_ENTRY_delete(sk, where) \

  808.   ((BY_DIR_ENTRY *)sk_delete(             \

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

  810. 

  811. #define sk_BY_DIR_ENTRY_delete_ptr(sk, p)                   \

  812.   ((BY_DIR_ENTRY *)sk_delete_ptr(                           \

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

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

  815. 

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

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

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

  819. 

  820. #define sk_BY_DIR_ENTRY_shift(sk) \

  821.   ((BY_DIR_ENTRY *)sk_shift(      \

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

  823. 

  824. #define sk_BY_DIR_ENTRY_push(sk, p)                             \

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

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

  827. 

  828. #define sk_BY_DIR_ENTRY_pop(sk) \

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

  830. 

  831. #define sk_BY_DIR_ENTRY_dup(sk)      \

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

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

  834. 

  835. #define sk_BY_DIR_ENTRY_sort(sk) \

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

  837. 

  838. #define sk_BY_DIR_ENTRY_is_sorted(sk) \

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

  840. 

  841. #define sk_BY_DIR_ENTRY_set_cmp_func(sk, comp)                               \

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

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

  844.       CHECKED_CAST(stack_cmp_func,                                           \

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

  846.                    comp)))

  847. 

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

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

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

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

  852.                    copy_func),                                           \

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

  854. 

  855. /* BY_DIR_HASH */

  856. #define sk_BY_DIR_HASH_new(comp)                                             \

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

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

  859.       comp)))

  860. 

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

  862. 

  863. #define sk_BY_DIR_HASH_num(sk) \

  864.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk))

  865. 

  866. #define sk_BY_DIR_HASH_zero(sk) \

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

  868. 

  869. #define sk_BY_DIR_HASH_value(sk, i) \

  870.   ((BY_DIR_HASH *)sk_value(         \

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

  872. 

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

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

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

  876. 

  877. #define sk_BY_DIR_HASH_free(sk) \

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

  879. 

  880. #define sk_BY_DIR_HASH_pop_free(sk, free_func)             \

  881.   sk_pop_free(                                             \

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

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

  884. 

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

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

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

  888. 

  889. #define sk_BY_DIR_HASH_delete(sk, where) \

  890.   ((BY_DIR_HASH *)sk_delete(             \

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

  892. 

  893. #define sk_BY_DIR_HASH_delete_ptr(sk, p)                   \

  894.   ((BY_DIR_HASH *)sk_delete_ptr(                           \

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

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

  897. 

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

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

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

  901. 

  902. #define sk_BY_DIR_HASH_shift(sk) \

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

  904. 

  905. #define sk_BY_DIR_HASH_push(sk, p)                             \

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

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

  908. 

  909. #define sk_BY_DIR_HASH_pop(sk) \

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

  911. 

  912. #define sk_BY_DIR_HASH_dup(sk)      \

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

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

  915. 

  916. #define sk_BY_DIR_HASH_sort(sk) \

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

  918. 

  919. #define sk_BY_DIR_HASH_is_sorted(sk) \

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

  921. 

  922. #define sk_BY_DIR_HASH_set_cmp_func(sk, comp)                              \

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

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

  925.       CHECKED_CAST(stack_cmp_func,                                         \

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

  927.                    comp)))

  928. 

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

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

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

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

  933.                    copy_func),                                         \

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

  935. 

  936. /* CONF_VALUE */

  937. #define sk_CONF_VALUE_new(comp)                                            \

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

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

  940.       comp)))

  941. 

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

  943. 

  944. #define sk_CONF_VALUE_num(sk) \

  945.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk))

  946. 

  947. #define sk_CONF_VALUE_zero(sk) \

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

  949. 

  950. #define sk_CONF_VALUE_value(sk, i) \

  951.   ((CONF_VALUE *)sk_value(         \

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

  953. 

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

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

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

  957. 

  958. #define sk_CONF_VALUE_free(sk) \

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

  960. 

  961. #define sk_CONF_VALUE_pop_free(sk, free_func)             \

  962.   sk_pop_free(                                            \

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

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

  965. 

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

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

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

  969. 

  970. #define sk_CONF_VALUE_delete(sk, where)                                        \

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

  972.                            (where)))

  973. 

  974. #define sk_CONF_VALUE_delete_ptr(sk, p)                   \

  975.   ((CONF_VALUE *)sk_delete_ptr(                           \

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

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

  978. 

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

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

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

  982. 

  983. #define sk_CONF_VALUE_shift(sk) \

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

  985. 

  986. #define sk_CONF_VALUE_push(sk, p)                             \

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

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

  989. 

  990. #define sk_CONF_VALUE_pop(sk) \

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

  992. 

  993. #define sk_CONF_VALUE_dup(sk)      \

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

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

  996. 

  997. #define sk_CONF_VALUE_sort(sk) \

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

  999. 

  1000. #define sk_CONF_VALUE_is_sorted(sk) \

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

  1002. 

  1003. #define sk_CONF_VALUE_set_cmp_func(sk, comp)                             \

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

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

  1006.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1008.                    comp)))

  1009. 

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

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

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

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

  1014.                    copy_func),                                        \

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

  1016. 

  1017. /* CRYPTO_BUFFER */

  1018. #define sk_CRYPTO_BUFFER_new(comp)                 \

  1019.   ((STACK_OF(CRYPTO_BUFFER) *)sk_new(CHECKED_CAST( \

  1020.       stack_cmp_func,                              \

  1021.       int (*)(const CRYPTO_BUFFER **a, const CRYPTO_BUFFER **b), comp)))

  1022. 

  1023. #define sk_CRYPTO_BUFFER_new_null() ((STACK_OF(CRYPTO_BUFFER) *)sk_new_null())

  1024. 

  1025. #define sk_CRYPTO_BUFFER_num(sk) \

  1026.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_BUFFER) *, sk))

  1027. 

  1028. #define sk_CRYPTO_BUFFER_zero(sk) \

  1029.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk));

  1030. 

  1031. #define sk_CRYPTO_BUFFER_value(sk, i) \

  1032.   ((CRYPTO_BUFFER *)sk_value(         \

  1033.       CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_BUFFER) *, sk), (i)))

  1034. 

  1035. #define sk_CRYPTO_BUFFER_set(sk, i, p)                            \

  1036.   ((CRYPTO_BUFFER *)sk_set(                                       \

  1037.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), (i), \

  1038.       CHECKED_CAST(void *, CRYPTO_BUFFER *, p)))

  1039. 

  1040. #define sk_CRYPTO_BUFFER_free(sk) \

  1041.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk))

  1042. 

  1043. #define sk_CRYPTO_BUFFER_pop_free(sk, free_func)             \

  1044.   sk_pop_free(                                               \

  1045.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), \

  1046.       CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_BUFFER *), free_func))

  1047. 

  1048. #define sk_CRYPTO_BUFFER_insert(sk, p, where)                      \

  1049.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), \

  1050.             CHECKED_CAST(void *, CRYPTO_BUFFER *, p), (where))

  1051. 

  1052. #define sk_CRYPTO_BUFFER_delete(sk, where) \

  1053.   ((CRYPTO_BUFFER *)sk_delete(             \

  1054.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), (where)))

  1055. 

  1056. #define sk_CRYPTO_BUFFER_delete_ptr(sk, p)                   \

  1057.   ((CRYPTO_BUFFER *)sk_delete_ptr(                           \

  1058.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), \

  1059.       CHECKED_CAST(void *, CRYPTO_BUFFER *, p)))

  1060. 

  1061. #define sk_CRYPTO_BUFFER_find(sk, out_index, p)                               \

  1062.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), (out_index), \

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

  1064. 

  1065. #define sk_CRYPTO_BUFFER_shift(sk) \

  1066.   ((CRYPTO_BUFFER *)sk_shift(      \

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

  1068. 

  1069. #define sk_CRYPTO_BUFFER_push(sk, p)                             \

  1070.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk), \

  1071.           CHECKED_CAST(void *, CRYPTO_BUFFER *, p))

  1072. 

  1073. #define sk_CRYPTO_BUFFER_pop(sk) \

  1074.   ((CRYPTO_BUFFER *)sk_pop(      \

  1075.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk)))

  1076. 

  1077. #define sk_CRYPTO_BUFFER_dup(sk)      \

  1078.   ((STACK_OF(CRYPTO_BUFFER) *)sk_dup( \

  1079.       CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_BUFFER) *, sk)))

  1080. 

  1081. #define sk_CRYPTO_BUFFER_sort(sk) \

  1082.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk))

  1083. 

  1084. #define sk_CRYPTO_BUFFER_is_sorted(sk) \

  1085.   sk_is_sorted(                        \

  1086.       CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_BUFFER) *, sk))

  1087. 

  1088. #define sk_CRYPTO_BUFFER_set_cmp_func(sk, comp)                                \

  1089.   ((int (*)(const CRYPTO_BUFFER **a, const CRYPTO_BUFFER **b))sk_set_cmp_func( \

  1090.       CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_BUFFER) *, sk),                   \

  1091.       CHECKED_CAST(stack_cmp_func,                                             \

  1092.                    int (*)(const CRYPTO_BUFFER **a, const CRYPTO_BUFFER **b),  \

  1093.                    comp)))

  1094. 

  1095. #define sk_CRYPTO_BUFFER_deep_copy(sk, copy_func, free_func)               \

  1096.   ((STACK_OF(CRYPTO_BUFFER) *)sk_deep_copy(                                \

  1097.       CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_BUFFER) *, sk),   \

  1098.       CHECKED_CAST(void *(*)(void *), CRYPTO_BUFFER *(*)(CRYPTO_BUFFER *), \

  1099.                    copy_func),                                             \

  1100.       CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_BUFFER *), free_func)))

  1101. 

  1102. /* CRYPTO_EX_DATA_FUNCS */

  1103. #define sk_CRYPTO_EX_DATA_FUNCS_new(comp)                                      \

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

  1105.       stack_cmp_func,                                                          \

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

  1107.       comp)))

  1108. 

  1109. #define sk_CRYPTO_EX_DATA_FUNCS_new_null() \

  1110.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())

  1111. 

  1112. #define sk_CRYPTO_EX_DATA_FUNCS_num(sk)                                       \

  1113.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \

  1114.                       sk))

  1115. 

  1116. #define sk_CRYPTO_EX_DATA_FUNCS_zero(sk) \

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

  1118. 

  1119. #define sk_CRYPTO_EX_DATA_FUNCS_value(sk, i)                               \

  1120.   ((CRYPTO_EX_DATA_FUNCS *)sk_value(                                       \

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

  1122.                    sk),                                                    \

  1123.       (i)))

  1124. 

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

  1126.   ((CRYPTO_EX_DATA_FUNCS *)sk_set(                                       \

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

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

  1129. 

  1130. #define sk_CRYPTO_EX_DATA_FUNCS_free(sk) \

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

  1132. 

  1133. #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func)                        \

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

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

  1136.                            free_func))

  1137. 

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

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

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

  1141. 

  1142. #define sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where) \

  1143.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete(             \

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

  1145. 

  1146. #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p)                   \

  1147.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr(                           \

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

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

  1150. 

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

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

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

  1154. 

  1155. #define sk_CRYPTO_EX_DATA_FUNCS_shift(sk) \

  1156.   ((CRYPTO_EX_DATA_FUNCS *)sk_shift(      \

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

  1158. 

  1159. #define sk_CRYPTO_EX_DATA_FUNCS_push(sk, p)                             \

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

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

  1162. 

  1163. #define sk_CRYPTO_EX_DATA_FUNCS_pop(sk) \

  1164.   ((CRYPTO_EX_DATA_FUNCS *)sk_pop(      \

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

  1166. 

  1167. #define sk_CRYPTO_EX_DATA_FUNCS_dup(sk)                   \

  1168.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_dup(CHECKED_CAST( \

  1169.       const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

  1170. 

  1171. #define sk_CRYPTO_EX_DATA_FUNCS_sort(sk) \

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

  1173. 

  1174. #define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk) \

  1175.   sk_is_sorted(CHECKED_CAST(const _STACK *,   \

  1176.                             const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

  1177. 

  1178. #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp)                       \

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

  1180.        sk_set_cmp_func(                                                      \

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

  1182.            CHECKED_CAST(stack_cmp_func,                                      \

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

  1184.                                 const CRYPTO_EX_DATA_FUNCS **b),             \

  1185.                         comp)))

  1186. 

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

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

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

  1190.                    sk),                                                    \

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

  1192.                    CRYPTO_EX_DATA_FUNCS *(*)(CRYPTO_EX_DATA_FUNCS *),      \

  1193.                    copy_func),                                             \

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

  1195.                    free_func)))

  1196. 

  1197. /* DIST_POINT */

  1198. #define sk_DIST_POINT_new(comp)                                            \

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

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

  1201.       comp)))

  1202. 

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

  1204. 

  1205. #define sk_DIST_POINT_num(sk) \

  1206.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk))

  1207. 

  1208. #define sk_DIST_POINT_zero(sk) \

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

  1210. 

  1211. #define sk_DIST_POINT_value(sk, i) \

  1212.   ((DIST_POINT *)sk_value(         \

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

  1214. 

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

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

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

  1218. 

  1219. #define sk_DIST_POINT_free(sk) \

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

  1221. 

  1222. #define sk_DIST_POINT_pop_free(sk, free_func)             \

  1223.   sk_pop_free(                                            \

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

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

  1226. 

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

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

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

  1230. 

  1231. #define sk_DIST_POINT_delete(sk, where)                                        \

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

  1233.                            (where)))

  1234. 

  1235. #define sk_DIST_POINT_delete_ptr(sk, p)                   \

  1236.   ((DIST_POINT *)sk_delete_ptr(                           \

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

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

  1239. 

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

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

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

  1243. 

  1244. #define sk_DIST_POINT_shift(sk) \

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

  1246. 

  1247. #define sk_DIST_POINT_push(sk, p)                             \

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

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

  1250. 

  1251. #define sk_DIST_POINT_pop(sk) \

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

  1253. 

  1254. #define sk_DIST_POINT_dup(sk)      \

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

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

  1257. 

  1258. #define sk_DIST_POINT_sort(sk) \

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

  1260. 

  1261. #define sk_DIST_POINT_is_sorted(sk) \

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

  1263. 

  1264. #define sk_DIST_POINT_set_cmp_func(sk, comp)                             \

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

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

  1267.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1269.                    comp)))

  1270. 

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

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

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

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

  1275.                    copy_func),                                        \

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

  1277. 

  1278. /* GENERAL_NAME */

  1279. #define sk_GENERAL_NAME_new(comp)                                              \

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

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

  1282.       comp)))

  1283. 

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

  1285. 

  1286. #define sk_GENERAL_NAME_num(sk) \

  1287.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk))

  1288. 

  1289. #define sk_GENERAL_NAME_zero(sk) \

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

  1291. 

  1292. #define sk_GENERAL_NAME_value(sk, i) \

  1293.   ((GENERAL_NAME *)sk_value(         \

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

  1295. 

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

  1297.   ((GENERAL_NAME *)sk_set(                                       \

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

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

  1300. 

  1301. #define sk_GENERAL_NAME_free(sk) \

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

  1303. 

  1304. #define sk_GENERAL_NAME_pop_free(sk, free_func)             \

  1305.   sk_pop_free(                                              \

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

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

  1308. 

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

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

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

  1312. 

  1313. #define sk_GENERAL_NAME_delete(sk, where) \

  1314.   ((GENERAL_NAME *)sk_delete(             \

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

  1316. 

  1317. #define sk_GENERAL_NAME_delete_ptr(sk, p)                   \

  1318.   ((GENERAL_NAME *)sk_delete_ptr(                           \

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

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

  1321. 

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

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

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

  1325. 

  1326. #define sk_GENERAL_NAME_shift(sk) \

  1327.   ((GENERAL_NAME *)sk_shift(      \

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

  1329. 

  1330. #define sk_GENERAL_NAME_push(sk, p)                             \

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

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

  1333. 

  1334. #define sk_GENERAL_NAME_pop(sk) \

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

  1336. 

  1337. #define sk_GENERAL_NAME_dup(sk)      \

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

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

  1340. 

  1341. #define sk_GENERAL_NAME_sort(sk) \

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

  1343. 

  1344. #define sk_GENERAL_NAME_is_sorted(sk) \

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

  1346. 

  1347. #define sk_GENERAL_NAME_set_cmp_func(sk, comp)                               \

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

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

  1350.       CHECKED_CAST(stack_cmp_func,                                           \

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

  1352.                    comp)))

  1353. 

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

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

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

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

  1358.                    copy_func),                                           \

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

  1360. 

  1361. /* GENERAL_NAMES */

  1362. #define sk_GENERAL_NAMES_new(comp)                 \

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

  1364.       stack_cmp_func,                              \

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

  1366. 

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

  1368. 

  1369. #define sk_GENERAL_NAMES_num(sk) \

  1370.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk))

  1371. 

  1372. #define sk_GENERAL_NAMES_zero(sk) \

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

  1374. 

  1375. #define sk_GENERAL_NAMES_value(sk, i) \

  1376.   ((GENERAL_NAMES *)sk_value(         \

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

  1378. 

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

  1380.   ((GENERAL_NAMES *)sk_set(                                       \

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

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

  1383. 

  1384. #define sk_GENERAL_NAMES_free(sk) \

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

  1386. 

  1387. #define sk_GENERAL_NAMES_pop_free(sk, free_func)             \

  1388.   sk_pop_free(                                               \

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

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

  1391. 

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

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

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

  1395. 

  1396. #define sk_GENERAL_NAMES_delete(sk, where) \

  1397.   ((GENERAL_NAMES *)sk_delete(             \

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

  1399. 

  1400. #define sk_GENERAL_NAMES_delete_ptr(sk, p)                   \

  1401.   ((GENERAL_NAMES *)sk_delete_ptr(                           \

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

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

  1404. 

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

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

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

  1408. 

  1409. #define sk_GENERAL_NAMES_shift(sk) \

  1410.   ((GENERAL_NAMES *)sk_shift(      \

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

  1412. 

  1413. #define sk_GENERAL_NAMES_push(sk, p)                             \

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

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

  1416. 

  1417. #define sk_GENERAL_NAMES_pop(sk) \

  1418.   ((GENERAL_NAMES *)sk_pop(      \

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

  1420. 

  1421. #define sk_GENERAL_NAMES_dup(sk)      \

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

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

  1424. 

  1425. #define sk_GENERAL_NAMES_sort(sk) \

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

  1427. 

  1428. #define sk_GENERAL_NAMES_is_sorted(sk) \

  1429.   sk_is_sorted(                        \

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

  1431. 

  1432. #define sk_GENERAL_NAMES_set_cmp_func(sk, comp)                                \

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

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

  1435.       CHECKED_CAST(stack_cmp_func,                                             \

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

  1437.                    comp)))

  1438. 

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

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

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

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

  1443.                    copy_func),                                             \

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

  1445. 

  1446. /* GENERAL_SUBTREE */

  1447. #define sk_GENERAL_SUBTREE_new(comp)                 \

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

  1449.       stack_cmp_func,                                \

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

  1451. 

  1452. #define sk_GENERAL_SUBTREE_new_null() \

  1453.   ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())

  1454. 

  1455. #define sk_GENERAL_SUBTREE_num(sk) \

  1456.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))

  1457. 

  1458. #define sk_GENERAL_SUBTREE_zero(sk) \

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

  1460. 

  1461. #define sk_GENERAL_SUBTREE_value(sk, i)                                    \

  1462.   ((GENERAL_SUBTREE *)sk_value(                                            \

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

  1464.       (i)))

  1465. 

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

  1467.   ((GENERAL_SUBTREE *)sk_set(                                       \

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

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

  1470. 

  1471. #define sk_GENERAL_SUBTREE_free(sk) \

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

  1473. 

  1474. #define sk_GENERAL_SUBTREE_pop_free(sk, free_func)             \

  1475.   sk_pop_free(                                                 \

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

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

  1478. 

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

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

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

  1482. 

  1483. #define sk_GENERAL_SUBTREE_delete(sk, where) \

  1484.   ((GENERAL_SUBTREE *)sk_delete(             \

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

  1486. 

  1487. #define sk_GENERAL_SUBTREE_delete_ptr(sk, p)                   \

  1488.   ((GENERAL_SUBTREE *)sk_delete_ptr(                           \

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

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

  1491. 

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

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

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

  1495. 

  1496. #define sk_GENERAL_SUBTREE_shift(sk) \

  1497.   ((GENERAL_SUBTREE *)sk_shift(      \

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

  1499. 

  1500. #define sk_GENERAL_SUBTREE_push(sk, p)                             \

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

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

  1503. 

  1504. #define sk_GENERAL_SUBTREE_pop(sk) \

  1505.   ((GENERAL_SUBTREE *)sk_pop(      \

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

  1507. 

  1508. #define sk_GENERAL_SUBTREE_dup(sk)      \

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

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

  1511. 

  1512. #define sk_GENERAL_SUBTREE_sort(sk) \

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

  1514. 

  1515. #define sk_GENERAL_SUBTREE_is_sorted(sk) \

  1516.   sk_is_sorted(                          \

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

  1518. 

  1519. #define sk_GENERAL_SUBTREE_set_cmp_func(sk, comp)                           \

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

  1521.        sk_set_cmp_func(                                                     \

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

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

  1524.                                                 const GENERAL_SUBTREE **b), \

  1525.                         comp)))

  1526. 

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

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

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

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

  1531.                    copy_func),                                                 \

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

  1533. 

  1534. /* POLICYINFO */

  1535. #define sk_POLICYINFO_new(comp)                                            \

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

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

  1538.       comp)))

  1539. 

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

  1541. 

  1542. #define sk_POLICYINFO_num(sk) \

  1543.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk))

  1544. 

  1545. #define sk_POLICYINFO_zero(sk) \

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

  1547. 

  1548. #define sk_POLICYINFO_value(sk, i) \

  1549.   ((POLICYINFO *)sk_value(         \

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

  1551. 

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

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

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

  1555. 

  1556. #define sk_POLICYINFO_free(sk) \

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

  1558. 

  1559. #define sk_POLICYINFO_pop_free(sk, free_func)             \

  1560.   sk_pop_free(                                            \

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

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

  1563. 

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

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

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

  1567. 

  1568. #define sk_POLICYINFO_delete(sk, where)                                        \

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

  1570.                            (where)))

  1571. 

  1572. #define sk_POLICYINFO_delete_ptr(sk, p)                   \

  1573.   ((POLICYINFO *)sk_delete_ptr(                           \

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

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

  1576. 

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

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

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

  1580. 

  1581. #define sk_POLICYINFO_shift(sk) \

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

  1583. 

  1584. #define sk_POLICYINFO_push(sk, p)                             \

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

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

  1587. 

  1588. #define sk_POLICYINFO_pop(sk) \

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

  1590. 

  1591. #define sk_POLICYINFO_dup(sk)      \

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

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

  1594. 

  1595. #define sk_POLICYINFO_sort(sk) \

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

  1597. 

  1598. #define sk_POLICYINFO_is_sorted(sk) \

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

  1600. 

  1601. #define sk_POLICYINFO_set_cmp_func(sk, comp)                             \

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

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

  1604.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1606.                    comp)))

  1607. 

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

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

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

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

  1612.                    copy_func),                                        \

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

  1614. 

  1615. /* POLICYQUALINFO */

  1616. #define sk_POLICYQUALINFO_new(comp)                 \

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

  1618.       stack_cmp_func,                               \

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

  1620. 

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

  1622. 

  1623. #define sk_POLICYQUALINFO_num(sk) \

  1624.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk))

  1625. 

  1626. #define sk_POLICYQUALINFO_zero(sk) \

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

  1628. 

  1629. #define sk_POLICYQUALINFO_value(sk, i)                                    \

  1630.   ((POLICYQUALINFO *)sk_value(                                            \

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

  1632.       (i)))

  1633. 

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

  1635.   ((POLICYQUALINFO *)sk_set(                                       \

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

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

  1638. 

  1639. #define sk_POLICYQUALINFO_free(sk) \

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

  1641. 

  1642. #define sk_POLICYQUALINFO_pop_free(sk, free_func)             \

  1643.   sk_pop_free(                                                \

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

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

  1646. 

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

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

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

  1650. 

  1651. #define sk_POLICYQUALINFO_delete(sk, where) \

  1652.   ((POLICYQUALINFO *)sk_delete(             \

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

  1654. 

  1655. #define sk_POLICYQUALINFO_delete_ptr(sk, p)                   \

  1656.   ((POLICYQUALINFO *)sk_delete_ptr(                           \

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

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

  1659. 

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

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

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

  1663. 

  1664. #define sk_POLICYQUALINFO_shift(sk) \

  1665.   ((POLICYQUALINFO *)sk_shift(      \

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

  1667. 

  1668. #define sk_POLICYQUALINFO_push(sk, p)                             \

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

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

  1671. 

  1672. #define sk_POLICYQUALINFO_pop(sk) \

  1673.   ((POLICYQUALINFO *)sk_pop(      \

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

  1675. 

  1676. #define sk_POLICYQUALINFO_dup(sk)      \

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

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

  1679. 

  1680. #define sk_POLICYQUALINFO_sort(sk) \

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

  1682. 

  1683. #define sk_POLICYQUALINFO_is_sorted(sk) \

  1684.   sk_is_sorted(                         \

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

  1686. 

  1687. #define sk_POLICYQUALINFO_set_cmp_func(sk, comp)                           \

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

  1689.        sk_set_cmp_func(                                                    \

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

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

  1692.                                                 const POLICYQUALINFO **b), \

  1693.                         comp)))

  1694. 

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

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

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

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

  1699.                    copy_func),                                               \

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

  1701. 

  1702. /* POLICY_MAPPING */

  1703. #define sk_POLICY_MAPPING_new(comp)                 \

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

  1705.       stack_cmp_func,                               \

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

  1707. 

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

  1709. 

  1710. #define sk_POLICY_MAPPING_num(sk) \

  1711.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk))

  1712. 

  1713. #define sk_POLICY_MAPPING_zero(sk) \

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

  1715. 

  1716. #define sk_POLICY_MAPPING_value(sk, i)                                    \

  1717.   ((POLICY_MAPPING *)sk_value(                                            \

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

  1719.       (i)))

  1720. 

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

  1722.   ((POLICY_MAPPING *)sk_set(                                       \

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

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

  1725. 

  1726. #define sk_POLICY_MAPPING_free(sk) \

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

  1728. 

  1729. #define sk_POLICY_MAPPING_pop_free(sk, free_func)             \

  1730.   sk_pop_free(                                                \

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

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

  1733. 

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

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

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

  1737. 

  1738. #define sk_POLICY_MAPPING_delete(sk, where) \

  1739.   ((POLICY_MAPPING *)sk_delete(             \

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

  1741. 

  1742. #define sk_POLICY_MAPPING_delete_ptr(sk, p)                   \

  1743.   ((POLICY_MAPPING *)sk_delete_ptr(                           \

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

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

  1746. 

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

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

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

  1750. 

  1751. #define sk_POLICY_MAPPING_shift(sk) \

  1752.   ((POLICY_MAPPING *)sk_shift(      \

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

  1754. 

  1755. #define sk_POLICY_MAPPING_push(sk, p)                             \

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

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

  1758. 

  1759. #define sk_POLICY_MAPPING_pop(sk) \

  1760.   ((POLICY_MAPPING *)sk_pop(      \

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

  1762. 

  1763. #define sk_POLICY_MAPPING_dup(sk)      \

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

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

  1766. 

  1767. #define sk_POLICY_MAPPING_sort(sk) \

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

  1769. 

  1770. #define sk_POLICY_MAPPING_is_sorted(sk) \

  1771.   sk_is_sorted(                         \

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

  1773. 

  1774. #define sk_POLICY_MAPPING_set_cmp_func(sk, comp)                           \

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

  1776.        sk_set_cmp_func(                                                    \

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

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

  1779.                                                 const POLICY_MAPPING **b), \

  1780.                         comp)))

  1781. 

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

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

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

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

  1786.                    copy_func),                                               \

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

  1788. 

  1789. /* RSA_additional_prime */

  1790. #define sk_RSA_additional_prime_new(comp)                                      \

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

  1792.       stack_cmp_func,                                                          \

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

  1794.       comp)))

  1795. 

  1796. #define sk_RSA_additional_prime_new_null() \

  1797.   ((STACK_OF(RSA_additional_prime) *)sk_new_null())

  1798. 

  1799. #define sk_RSA_additional_prime_num(sk)                                       \

  1800.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \

  1801.                       sk))

  1802. 

  1803. #define sk_RSA_additional_prime_zero(sk) \

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

  1805. 

  1806. #define sk_RSA_additional_prime_value(sk, i)                               \

  1807.   ((RSA_additional_prime *)sk_value(                                       \

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

  1809.                    sk),                                                    \

  1810.       (i)))

  1811. 

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

  1813.   ((RSA_additional_prime *)sk_set(                                       \

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

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

  1816. 

  1817. #define sk_RSA_additional_prime_free(sk) \

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

  1819. 

  1820. #define sk_RSA_additional_prime_pop_free(sk, free_func)                        \

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

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

  1823.                            free_func))

  1824. 

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

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

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

  1828. 

  1829. #define sk_RSA_additional_prime_delete(sk, where) \

  1830.   ((RSA_additional_prime *)sk_delete(             \

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

  1832. 

  1833. #define sk_RSA_additional_prime_delete_ptr(sk, p)                   \

  1834.   ((RSA_additional_prime *)sk_delete_ptr(                           \

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

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

  1837. 

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

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

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

  1841. 

  1842. #define sk_RSA_additional_prime_shift(sk) \

  1843.   ((RSA_additional_prime *)sk_shift(      \

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

  1845. 

  1846. #define sk_RSA_additional_prime_push(sk, p)                             \

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

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

  1849. 

  1850. #define sk_RSA_additional_prime_pop(sk) \

  1851.   ((RSA_additional_prime *)sk_pop(      \

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

  1853. 

  1854. #define sk_RSA_additional_prime_dup(sk)                   \

  1855.   ((STACK_OF(RSA_additional_prime) *)sk_dup(CHECKED_CAST( \

  1856.       const _STACK *, const STACK_OF(RSA_additional_prime) *, sk)))

  1857. 

  1858. #define sk_RSA_additional_prime_sort(sk) \

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

  1860. 

  1861. #define sk_RSA_additional_prime_is_sorted(sk) \

  1862.   sk_is_sorted(CHECKED_CAST(const _STACK *,   \

  1863.                             const STACK_OF(RSA_additional_prime) *, sk))

  1864. 

  1865. #define sk_RSA_additional_prime_set_cmp_func(sk, comp)                       \

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

  1867.        sk_set_cmp_func(                                                      \

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

  1869.            CHECKED_CAST(stack_cmp_func,                                      \

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

  1871.                                 const RSA_additional_prime **b),             \

  1872.                         comp)))

  1873. 

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

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

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

  1877.                    sk),                                                    \

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

  1879.                    RSA_additional_prime *(*)(RSA_additional_prime *),      \

  1880.                    copy_func),                                             \

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

  1882.                    free_func)))

  1883. 

  1884. /* SSL_COMP */

  1885. #define sk_SSL_COMP_new(comp)                 \

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

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

  1888. 

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

  1890. 

  1891. #define sk_SSL_COMP_num(sk) \

  1892.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk))

  1893. 

  1894. #define sk_SSL_COMP_zero(sk) \

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

  1896. 

  1897. #define sk_SSL_COMP_value(sk, i) \

  1898.   ((SSL_COMP *)sk_value(         \

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

  1900. 

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

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

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

  1904. 

  1905. #define sk_SSL_COMP_free(sk) \

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

  1907. 

  1908. #define sk_SSL_COMP_pop_free(sk, free_func)                     \

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

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

  1911. 

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

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

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

  1915. 

  1916. #define sk_SSL_COMP_delete(sk, where)                                      \

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

  1918.                          (where)))

  1919. 

  1920. #define sk_SSL_COMP_delete_ptr(sk, p)                                          \

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

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

  1923. 

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

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

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

  1927. 

  1928. #define sk_SSL_COMP_shift(sk) \

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

  1930. 

  1931. #define sk_SSL_COMP_push(sk, p)                             \

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

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

  1934. 

  1935. #define sk_SSL_COMP_pop(sk) \

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

  1937. 

  1938. #define sk_SSL_COMP_dup(sk)      \

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

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

  1941. 

  1942. #define sk_SSL_COMP_sort(sk) \

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

  1944. 

  1945. #define sk_SSL_COMP_is_sorted(sk) \

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

  1947. 

  1948. #define sk_SSL_COMP_set_cmp_func(sk, comp)                           \

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

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

  1951.       CHECKED_CAST(stack_cmp_func,                                   \

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

  1953. 

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

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

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

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

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

  1959. 

  1960. /* SSL_CUSTOM_EXTENSION */

  1961. #define sk_SSL_CUSTOM_EXTENSION_new(comp)                                      \

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

  1963.       stack_cmp_func,                                                          \

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

  1965.       comp)))

  1966. 

  1967. #define sk_SSL_CUSTOM_EXTENSION_new_null() \

  1968.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null())

  1969. 

  1970. #define sk_SSL_CUSTOM_EXTENSION_num(sk)                                       \

  1971.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \

  1972.                       sk))

  1973. 

  1974. #define sk_SSL_CUSTOM_EXTENSION_zero(sk) \

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

  1976. 

  1977. #define sk_SSL_CUSTOM_EXTENSION_value(sk, i)                               \

  1978.   ((SSL_CUSTOM_EXTENSION *)sk_value(                                       \

  1979.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \

  1980.                    sk),                                                    \

  1981.       (i)))

  1982. 

  1983. #define sk_SSL_CUSTOM_EXTENSION_set(sk, i, p)                            \

  1984.   ((SSL_CUSTOM_EXTENSION *)sk_set(                                       \

  1985.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (i), \

  1986.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  1987. 

  1988. #define sk_SSL_CUSTOM_EXTENSION_free(sk) \

  1989.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  1990. 

  1991. #define sk_SSL_CUSTOM_EXTENSION_pop_free(sk, free_func)                        \

  1992.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),    \

  1993.               CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \

  1994.                            free_func))

  1995. 

  1996. #define sk_SSL_CUSTOM_EXTENSION_insert(sk, p, where)                      \

  1997.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  1998.             CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p), (where))

  1999. 

  2000. #define sk_SSL_CUSTOM_EXTENSION_delete(sk, where) \

  2001.   ((SSL_CUSTOM_EXTENSION *)sk_delete(             \

  2002.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (where)))

  2003. 

  2004. #define sk_SSL_CUSTOM_EXTENSION_delete_ptr(sk, p)                   \

  2005.   ((SSL_CUSTOM_EXTENSION *)sk_delete_ptr(                           \

  2006.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2007.       CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

  2008. 

  2009. #define sk_SSL_CUSTOM_EXTENSION_find(sk, out_index, p)                  \

  2010.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2011.           (out_index), CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  2012. 

  2013. #define sk_SSL_CUSTOM_EXTENSION_shift(sk) \

  2014.   ((SSL_CUSTOM_EXTENSION *)sk_shift(      \

  2015.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2016. 

  2017. #define sk_SSL_CUSTOM_EXTENSION_push(sk, p)                             \

  2018.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \

  2019.           CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

  2020. 

  2021. #define sk_SSL_CUSTOM_EXTENSION_pop(sk) \

  2022.   ((SSL_CUSTOM_EXTENSION *)sk_pop(      \

  2023.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2024. 

  2025. #define sk_SSL_CUSTOM_EXTENSION_dup(sk)                   \

  2026.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_dup(CHECKED_CAST( \

  2027.       const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

  2028. 

  2029. #define sk_SSL_CUSTOM_EXTENSION_sort(sk) \

  2030.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2031. 

  2032. #define sk_SSL_CUSTOM_EXTENSION_is_sorted(sk) \

  2033.   sk_is_sorted(CHECKED_CAST(const _STACK *,   \

  2034.                             const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

  2035. 

  2036. #define sk_SSL_CUSTOM_EXTENSION_set_cmp_func(sk, comp)                       \

  2037.   ((int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b)) \

  2038.        sk_set_cmp_func(                                                      \

  2039.            CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),     \

  2040.            CHECKED_CAST(stack_cmp_func,                                      \

  2041.                         int (*)(const SSL_CUSTOM_EXTENSION **a,              \

  2042.                                 const SSL_CUSTOM_EXTENSION **b),             \

  2043.                         comp)))

  2044. 

  2045. #define sk_SSL_CUSTOM_EXTENSION_deep_copy(sk, copy_func, free_func)        \

  2046.   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_deep_copy(                         \

  2047.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \

  2048.                    sk),                                                    \

  2049.       CHECKED_CAST(void *(*)(void *),                                      \

  2050.                    SSL_CUSTOM_EXTENSION *(*)(SSL_CUSTOM_EXTENSION *),      \

  2051.                    copy_func),                                             \

  2052.       CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *),     \

  2053.                    free_func)))

  2054. 

  2055. /* STACK_OF_X509_NAME_ENTRY */

  2056. #define sk_STACK_OF_X509_NAME_ENTRY_new(comp)                      \

  2057.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST(      \

  2058.       stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a,  \

  2059.                               const STACK_OF_X509_NAME_ENTRY **b), \

  2060.       comp)))

  2061. 

  2062. #define sk_STACK_OF_X509_NAME_ENTRY_new_null() \

  2063.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())

  2064. 

  2065. #define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \

  2066.   sk_num(CHECKED_CAST(const _STACK *,       \

  2067.                       const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2068. 

  2069. #define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \

  2070.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk));

  2071. 

  2072. #define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i)                               \

  2073.   ((STACK_OF_X509_NAME_ENTRY *)sk_value(                                       \

  2074.       CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \

  2075.                    sk),                                                        \

  2076.       (i)))

  2077. 

  2078. #define sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p)                            \

  2079.   ((STACK_OF_X509_NAME_ENTRY *)sk_set(                                       \

  2080.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \

  2081.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  2082. 

  2083. #define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \

  2084.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2085. 

  2086. #define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func)                \

  2087.   sk_pop_free(                                                             \

  2088.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk),    \

  2089.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \

  2090.                    free_func))

  2091. 

  2092. #define sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where)                      \

  2093.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2094.             CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where))

  2095. 

  2096. #define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where)                   \

  2097.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete(                               \

  2098.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2099.       (where)))

  2100. 

  2101. #define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  2102.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr(                           \

  2103.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2104.       CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

  2105. 

  2106. #define sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  2107.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2108.           (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  2109. 

  2110. #define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \

  2111.   ((STACK_OF_X509_NAME_ENTRY *)sk_shift(      \

  2112.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2113. 

  2114. #define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p)                             \

  2115.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2116.           CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

  2117. 

  2118. #define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \

  2119.   ((STACK_OF_X509_NAME_ENTRY *)sk_pop(      \

  2120.       CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2121. 

  2122. #define sk_STACK_OF_X509_NAME_ENTRY_dup(sk)                   \

  2123.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup(CHECKED_CAST( \

  2124.       const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

  2125. 

  2126. #define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \

  2127.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2128. 

  2129. #define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \

  2130.   sk_is_sorted(CHECKED_CAST(const _STACK *,       \

  2131.                             const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

  2132. 

  2133. #define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp)                   \

  2134.   ((int (*)(const STACK_OF_X509_NAME_ENTRY **a,                              \

  2135.             const STACK_OF_X509_NAME_ENTRY **b))                             \

  2136.        sk_set_cmp_func(                                                      \

  2137.            CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  2138.            CHECKED_CAST(stack_cmp_func,                                      \

  2139.                         int (*)(const STACK_OF_X509_NAME_ENTRY **a,          \

  2140.                                 const STACK_OF_X509_NAME_ENTRY **b),         \

  2141.                         comp)))

  2142. 

  2143. #define sk_STACK_OF_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)        \

  2144.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_deep_copy(                         \

  2145.       CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \

  2146.                    sk),                                                        \

  2147.       CHECKED_CAST(void *(*)(void *),                                          \

  2148.                    STACK_OF_X509_NAME_ENTRY *(*)(STACK_OF_X509_NAME_ENTRY *),  \

  2149.                    copy_func),                                                 \

  2150.       CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *),     \

  2151.                    free_func)))

  2152. 

  2153. /* SXNETID */

  2154. #define sk_SXNETID_new(comp)                 \

  2155.   ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \

  2156.       stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2157. 

  2158. #define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null())

  2159. 

  2160. #define sk_SXNETID_num(sk) \

  2161.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))

  2162. 

  2163. #define sk_SXNETID_zero(sk) \

  2164.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));

  2165. 

  2166. #define sk_SXNETID_value(sk, i) \

  2167.   ((SXNETID *)sk_value(         \

  2168.       CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk), (i)))

  2169. 

  2170. #define sk_SXNETID_set(sk, i, p)                                           \

  2171.   ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \

  2172.                      CHECKED_CAST(void *, SXNETID *, p)))

  2173. 

  2174. #define sk_SXNETID_free(sk) \

  2175.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2176. 

  2177. #define sk_SXNETID_pop_free(sk, free_func)                     \

  2178.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2179.               CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))

  2180. 

  2181. #define sk_SXNETID_insert(sk, p, where)                      \

  2182.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2183.             CHECKED_CAST(void *, SXNETID *, p), (where))

  2184. 

  2185. #define sk_SXNETID_delete(sk, where)                                     \

  2186.   ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2187.                         (where)))

  2188. 

  2189. #define sk_SXNETID_delete_ptr(sk, p)                                         \

  2190.   ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2191.                             CHECKED_CAST(void *, SXNETID *, p)))

  2192. 

  2193. #define sk_SXNETID_find(sk, out_index, p)                               \

  2194.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \

  2195.           CHECKED_CAST(void *, SXNETID *, p))

  2196. 

  2197. #define sk_SXNETID_shift(sk) \

  2198.   ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2199. 

  2200. #define sk_SXNETID_push(sk, p)                             \

  2201.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2202.           CHECKED_CAST(void *, SXNETID *, p))

  2203. 

  2204. #define sk_SXNETID_pop(sk) \

  2205.   ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2206. 

  2207. #define sk_SXNETID_dup(sk)      \

  2208.   ((STACK_OF(SXNETID) *)sk_dup( \

  2209.       CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk)))

  2210. 

  2211. #define sk_SXNETID_sort(sk) \

  2212.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2213. 

  2214. #define sk_SXNETID_is_sorted(sk) \

  2215.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))

  2216. 

  2217. #define sk_SXNETID_set_cmp_func(sk, comp)                          \

  2218.   ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \

  2219.       CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk),             \

  2220.       CHECKED_CAST(stack_cmp_func,                                 \

  2221.                    int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2222. 

  2223. #define sk_SXNETID_deep_copy(sk, copy_func, free_func)                     \

  2224.   ((STACK_OF(SXNETID) *)sk_deep_copy(                                      \

  2225.       CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk),         \

  2226.       CHECKED_CAST(void *(*)(void *), SXNETID *(*)(SXNETID *), copy_func), \

  2227.       CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func)))

  2228. 

  2229. /* X509 */

  2230. #define sk_X509_new(comp)                 \

  2231.   ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \

  2232.       stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))

  2233. 

  2234. #define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null())

  2235. 

  2236. #define sk_X509_num(sk) \

  2237.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))

  2238. 

  2239. #define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));

  2240. 

  2241. #define sk_X509_value(sk, i)                                                  \

  2242.   ((X509 *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk), \

  2243.                     (i)))

  2244. 

  2245. #define sk_X509_set(sk, i, p)                                        \

  2246.   ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \

  2247.                   CHECKED_CAST(void *, X509 *, p)))

  2248. 

  2249. #define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2250. 

  2251. #define sk_X509_pop_free(sk, free_func)                     \

  2252.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2253.               CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))

  2254. 

  2255. #define sk_X509_insert(sk, p, where)                      \

  2256.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2257.             CHECKED_CAST(void *, X509 *, p), (where))

  2258. 

  2259. #define sk_X509_delete(sk, where) \

  2260.   ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))

  2261. 

  2262. #define sk_X509_delete_ptr(sk, p)                                      \

  2263.   ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2264.                          CHECKED_CAST(void *, X509 *, p)))

  2265. 

  2266. #define sk_X509_find(sk, out_index, p)                               \

  2267.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \

  2268.           CHECKED_CAST(void *, X509 *, p))

  2269. 

  2270. #define sk_X509_shift(sk) \

  2271.   ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2272. 

  2273. #define sk_X509_push(sk, p)                             \

  2274.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2275.           CHECKED_CAST(void *, X509 *, p))

  2276. 

  2277. #define sk_X509_pop(sk) \

  2278.   ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2279. 

  2280. #define sk_X509_dup(sk)      \

  2281.   ((STACK_OF(X509) *)sk_dup( \

  2282.       CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk)))

  2283. 

  2284. #define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2285. 

  2286. #define sk_X509_is_sorted(sk) \

  2287.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))

  2288. 

  2289. #define sk_X509_set_cmp_func(sk, comp)                                      \

  2290.   ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func(                \

  2291.       CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk),                         \

  2292.       CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \

  2293.                    comp)))

  2294. 

  2295. #define sk_X509_deep_copy(sk, copy_func, free_func)                  \

  2296.   ((STACK_OF(X509) *)sk_deep_copy(                                   \

  2297.       CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk),      \

  2298.       CHECKED_CAST(void *(*)(void *), X509 *(*)(X509 *), copy_func), \

  2299.       CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func)))

  2300. 

  2301. /* X509V3_EXT_METHOD */

  2302. #define sk_X509V3_EXT_METHOD_new(comp)                                   \

  2303.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST(                   \

  2304.       stack_cmp_func,                                                    \

  2305.       int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \

  2306.       comp)))

  2307. 

  2308. #define sk_X509V3_EXT_METHOD_new_null() \

  2309.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())

  2310. 

  2311. #define sk_X509V3_EXT_METHOD_num(sk) \

  2312.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

  2313. 

  2314. #define sk_X509V3_EXT_METHOD_zero(sk) \

  2315.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));

  2316. 

  2317. #define sk_X509V3_EXT_METHOD_value(sk, i)                                    \

  2318.   ((X509V3_EXT_METHOD *)sk_value(                                            \

  2319.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2320.       (i)))

  2321. 

  2322. #define sk_X509V3_EXT_METHOD_set(sk, i, p)                            \

  2323.   ((X509V3_EXT_METHOD *)sk_set(                                       \

  2324.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \

  2325.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2326. 

  2327. #define sk_X509V3_EXT_METHOD_free(sk) \

  2328.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2329. 

  2330. #define sk_X509V3_EXT_METHOD_pop_free(sk, free_func)                        \

  2331.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),    \

  2332.               CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \

  2333.                            free_func))

  2334. 

  2335. #define sk_X509V3_EXT_METHOD_insert(sk, p, where)                      \

  2336.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2337.             CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))

  2338. 

  2339. #define sk_X509V3_EXT_METHOD_delete(sk, where) \

  2340.   ((X509V3_EXT_METHOD *)sk_delete(             \

  2341.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))

  2342. 

  2343. #define sk_X509V3_EXT_METHOD_delete_ptr(sk, p)                   \

  2344.   ((X509V3_EXT_METHOD *)sk_delete_ptr(                           \

  2345.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2346.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2347. 

  2348. #define sk_X509V3_EXT_METHOD_find(sk, out_index, p)                  \

  2349.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2350.           (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2351. 

  2352. #define sk_X509V3_EXT_METHOD_shift(sk) \

  2353.   ((X509V3_EXT_METHOD *)sk_shift(      \

  2354.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2355. 

  2356. #define sk_X509V3_EXT_METHOD_push(sk, p)                             \

  2357.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2358.           CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2359. 

  2360. #define sk_X509V3_EXT_METHOD_pop(sk) \

  2361.   ((X509V3_EXT_METHOD *)sk_pop(      \

  2362.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2363. 

  2364. #define sk_X509V3_EXT_METHOD_dup(sk)      \

  2365.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \

  2366.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2367. 

  2368. #define sk_X509V3_EXT_METHOD_sort(sk) \

  2369.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2370. 

  2371. #define sk_X509V3_EXT_METHOD_is_sorted(sk) \

  2372.   sk_is_sorted(                            \

  2373.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

  2374. 

  2375. #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp)                           \

  2376.   ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b))        \

  2377.        sk_set_cmp_func(                                                       \

  2378.            CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),         \

  2379.            CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a,  \

  2380.                                                 const X509V3_EXT_METHOD **b), \

  2381.                         comp)))

  2382. 

  2383. #define sk_X509V3_EXT_METHOD_deep_copy(sk, copy_func, free_func)             \

  2384.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_deep_copy(                              \

  2385.       CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2386.       CHECKED_CAST(void *(*)(void *),                                        \

  2387.                    X509V3_EXT_METHOD *(*)(X509V3_EXT_METHOD *), copy_func),  \

  2388.       CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *),          \

  2389.                    free_func)))

  2390. 

  2391. /* X509_ALGOR */

  2392. #define sk_X509_ALGOR_new(comp)                                            \

  2393.   ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST(                            \

  2394.       stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \

  2395.       comp)))

  2396. 

  2397. #define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null())

  2398. 

  2399. #define sk_X509_ALGOR_num(sk) \

  2400.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))

  2401. 

  2402. #define sk_X509_ALGOR_zero(sk) \

  2403.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));

  2404. 

  2405. #define sk_X509_ALGOR_value(sk, i) \

  2406.   ((X509_ALGOR *)sk_value(         \

  2407.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))

  2408. 

  2409. #define sk_X509_ALGOR_set(sk, i, p)                                         \

  2410.   ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2411.                         (i), CHECKED_CAST(void *, X509_ALGOR *, p)))

  2412. 

  2413. #define sk_X509_ALGOR_free(sk) \

  2414.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2415. 

  2416. #define sk_X509_ALGOR_pop_free(sk, free_func)             \

  2417.   sk_pop_free(                                            \

  2418.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2419.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))

  2420. 

  2421. #define sk_X509_ALGOR_insert(sk, p, where)                      \

  2422.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2423.             CHECKED_CAST(void *, X509_ALGOR *, p), (where))

  2424. 

  2425. #define sk_X509_ALGOR_delete(sk, where)                                        \

  2426.   ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2427.                            (where)))

  2428. 

  2429. #define sk_X509_ALGOR_delete_ptr(sk, p)                   \

  2430.   ((X509_ALGOR *)sk_delete_ptr(                           \

  2431.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2432.       CHECKED_CAST(void *, X509_ALGOR *, p)))

  2433. 

  2434. #define sk_X509_ALGOR_find(sk, out_index, p)                               \

  2435.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \

  2436.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2437. 

  2438. #define sk_X509_ALGOR_shift(sk) \

  2439.   ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2440. 

  2441. #define sk_X509_ALGOR_push(sk, p)                             \

  2442.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2443.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2444. 

  2445. #define sk_X509_ALGOR_pop(sk) \

  2446.   ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2447. 

  2448. #define sk_X509_ALGOR_dup(sk)      \

  2449.   ((STACK_OF(X509_ALGOR) *)sk_dup( \

  2450.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk)))

  2451. 

  2452. #define sk_X509_ALGOR_sort(sk) \

  2453.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2454. 

  2455. #define sk_X509_ALGOR_is_sorted(sk) \

  2456.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))

  2457. 

  2458. #define sk_X509_ALGOR_set_cmp_func(sk, comp)                             \

  2459.   ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \

  2460.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk),                \

  2461.       CHECKED_CAST(stack_cmp_func,                                       \

  2462.                    int (*)(const X509_ALGOR **a, const X509_ALGOR **b),  \

  2463.                    comp)))

  2464. 

  2465. #define sk_X509_ALGOR_deep_copy(sk, copy_func, free_func)             \

  2466.   ((STACK_OF(X509_ALGOR) *)sk_deep_copy(                              \

  2467.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), \

  2468.       CHECKED_CAST(void *(*)(void *), X509_ALGOR *(*)(X509_ALGOR *),  \

  2469.                    copy_func),                                        \

  2470.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func)))

  2471. 

  2472. /* X509_ATTRIBUTE */

  2473. #define sk_X509_ATTRIBUTE_new(comp)                 \

  2474.   ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \

  2475.       stack_cmp_func,                               \

  2476.       int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))

  2477. 

  2478. #define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())

  2479. 

  2480. #define sk_X509_ATTRIBUTE_num(sk) \

  2481.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

  2482. 

  2483. #define sk_X509_ATTRIBUTE_zero(sk) \

  2484.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));

  2485. 

  2486. #define sk_X509_ATTRIBUTE_value(sk, i)                                    \

  2487.   ((X509_ATTRIBUTE *)sk_value(                                            \

  2488.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), \

  2489.       (i)))

  2490. 

  2491. #define sk_X509_ATTRIBUTE_set(sk, i, p)                            \

  2492.   ((X509_ATTRIBUTE *)sk_set(                                       \

  2493.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \

  2494.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2495. 

  2496. #define sk_X509_ATTRIBUTE_free(sk) \

  2497.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2498. 

  2499. #define sk_X509_ATTRIBUTE_pop_free(sk, free_func)             \

  2500.   sk_pop_free(                                                \

  2501.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2502.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))

  2503. 

  2504. #define sk_X509_ATTRIBUTE_insert(sk, p, where)                      \

  2505.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2506.             CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))

  2507. 

  2508. #define sk_X509_ATTRIBUTE_delete(sk, where) \

  2509.   ((X509_ATTRIBUTE *)sk_delete(             \

  2510.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))

  2511. 

  2512. #define sk_X509_ATTRIBUTE_delete_ptr(sk, p)                   \

  2513.   ((X509_ATTRIBUTE *)sk_delete_ptr(                           \

  2514.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2515.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2516. 

  2517. #define sk_X509_ATTRIBUTE_find(sk, out_index, p)                               \

  2518.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \

  2519.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2520. 

  2521. #define sk_X509_ATTRIBUTE_shift(sk) \

  2522.   ((X509_ATTRIBUTE *)sk_shift(      \

  2523.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2524. 

  2525. #define sk_X509_ATTRIBUTE_push(sk, p)                             \

  2526.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2527.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2528. 

  2529. #define sk_X509_ATTRIBUTE_pop(sk) \

  2530.   ((X509_ATTRIBUTE *)sk_pop(      \

  2531.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2532. 

  2533. #define sk_X509_ATTRIBUTE_dup(sk)      \

  2534.   ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \

  2535.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))

  2536. 

  2537. #define sk_X509_ATTRIBUTE_sort(sk) \

  2538.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2539. 

  2540. #define sk_X509_ATTRIBUTE_is_sorted(sk) \

  2541.   sk_is_sorted(                         \

  2542.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

  2543. 

  2544. #define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp)                           \

  2545.   ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b))           \

  2546.        sk_set_cmp_func(                                                    \

  2547.            CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk),         \

  2548.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a,  \

  2549.                                                 const X509_ATTRIBUTE **b), \

  2550.                         comp)))

  2551. 

  2552. #define sk_X509_ATTRIBUTE_deep_copy(sk, copy_func, free_func)                \

  2553.   ((STACK_OF(X509_ATTRIBUTE) *)sk_deep_copy(                                 \

  2554.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk),    \

  2555.       CHECKED_CAST(void *(*)(void *), X509_ATTRIBUTE *(*)(X509_ATTRIBUTE *), \

  2556.                    copy_func),                                               \

  2557.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func)))

  2558. 

  2559. /* X509_CRL */

  2560. #define sk_X509_CRL_new(comp)                 \

  2561.   ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \

  2562.       stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2563. 

  2564. #define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null())

  2565. 

  2566. #define sk_X509_CRL_num(sk) \

  2567.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))

  2568. 

  2569. #define sk_X509_CRL_zero(sk) \

  2570.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));

  2571. 

  2572. #define sk_X509_CRL_value(sk, i) \

  2573.   ((X509_CRL *)sk_value(         \

  2574.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk), (i)))

  2575. 

  2576. #define sk_X509_CRL_set(sk, i, p)                                            \

  2577.   ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \

  2578.                       CHECKED_CAST(void *, X509_CRL *, p)))

  2579. 

  2580. #define sk_X509_CRL_free(sk) \

  2581.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2582. 

  2583. #define sk_X509_CRL_pop_free(sk, free_func)                     \

  2584.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2585.               CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))

  2586. 

  2587. #define sk_X509_CRL_insert(sk, p, where)                      \

  2588.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2589.             CHECKED_CAST(void *, X509_CRL *, p), (where))

  2590. 

  2591. #define sk_X509_CRL_delete(sk, where)                                      \

  2592.   ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2593.                          (where)))

  2594. 

  2595. #define sk_X509_CRL_delete_ptr(sk, p)                                          \

  2596.   ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2597.                              CHECKED_CAST(void *, X509_CRL *, p)))

  2598. 

  2599. #define sk_X509_CRL_find(sk, out_index, p)                               \

  2600.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \

  2601.           CHECKED_CAST(void *, X509_CRL *, p))

  2602. 

  2603. #define sk_X509_CRL_shift(sk) \

  2604.   ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2605. 

  2606. #define sk_X509_CRL_push(sk, p)                             \

  2607.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2608.           CHECKED_CAST(void *, X509_CRL *, p))

  2609. 

  2610. #define sk_X509_CRL_pop(sk) \

  2611.   ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2612. 

  2613. #define sk_X509_CRL_dup(sk)      \

  2614.   ((STACK_OF(X509_CRL) *)sk_dup( \

  2615.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk)))

  2616. 

  2617. #define sk_X509_CRL_sort(sk) \

  2618.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2619. 

  2620. #define sk_X509_CRL_is_sorted(sk) \

  2621.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))

  2622. 

  2623. #define sk_X509_CRL_set_cmp_func(sk, comp)                           \

  2624.   ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \

  2625.       CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk),              \

  2626.       CHECKED_CAST(stack_cmp_func,                                   \

  2627.                    int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2628. 

  2629. #define sk_X509_CRL_deep_copy(sk, copy_func, free_func)                      \

  2630.   ((STACK_OF(X509_CRL) *)sk_deep_copy(                                       \

  2631.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk),          \

  2632.       CHECKED_CAST(void *(*)(void *), X509_CRL *(*)(X509_CRL *), copy_func), \

  2633.       CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func)))

  2634. 

  2635. /* X509_EXTENSION */

  2636. #define sk_X509_EXTENSION_new(comp)                 \

  2637.   ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \

  2638.       stack_cmp_func,                               \

  2639.       int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))

  2640. 

  2641. #define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null())

  2642. 

  2643. #define sk_X509_EXTENSION_num(sk) \

  2644.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))

  2645. 

  2646. #define sk_X509_EXTENSION_zero(sk) \

  2647.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));

  2648. 

  2649. #define sk_X509_EXTENSION_value(sk, i)                                    \

  2650.   ((X509_EXTENSION *)sk_value(                                            \

  2651.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk), \

  2652.       (i)))

  2653. 

  2654. #define sk_X509_EXTENSION_set(sk, i, p)                            \

  2655.   ((X509_EXTENSION *)sk_set(                                       \

  2656.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \

  2657.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2658. 

  2659. #define sk_X509_EXTENSION_free(sk) \

  2660.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2661. 

  2662. #define sk_X509_EXTENSION_pop_free(sk, free_func)             \

  2663.   sk_pop_free(                                                \

  2664.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2665.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))

  2666. 

  2667. #define sk_X509_EXTENSION_insert(sk, p, where)                      \

  2668.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2669.             CHECKED_CAST(void *, X509_EXTENSION *, p), (where))

  2670. 

  2671. #define sk_X509_EXTENSION_delete(sk, where) \

  2672.   ((X509_EXTENSION *)sk_delete(             \

  2673.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))

  2674. 

  2675. #define sk_X509_EXTENSION_delete_ptr(sk, p)                   \

  2676.   ((X509_EXTENSION *)sk_delete_ptr(                           \

  2677.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2678.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2679. 

  2680. #define sk_X509_EXTENSION_find(sk, out_index, p)                               \

  2681.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \

  2682.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2683. 

  2684. #define sk_X509_EXTENSION_shift(sk) \

  2685.   ((X509_EXTENSION *)sk_shift(      \

  2686.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2687. 

  2688. #define sk_X509_EXTENSION_push(sk, p)                             \

  2689.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2690.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2691. 

  2692. #define sk_X509_EXTENSION_pop(sk) \

  2693.   ((X509_EXTENSION *)sk_pop(      \

  2694.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2695. 

  2696. #define sk_X509_EXTENSION_dup(sk)      \

  2697.   ((STACK_OF(X509_EXTENSION) *)sk_dup( \

  2698.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk)))

  2699. 

  2700. #define sk_X509_EXTENSION_sort(sk) \

  2701.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2702. 

  2703. #define sk_X509_EXTENSION_is_sorted(sk) \

  2704.   sk_is_sorted(                         \

  2705.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))

  2706. 

  2707. #define sk_X509_EXTENSION_set_cmp_func(sk, comp)                           \

  2708.   ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b))           \

  2709.        sk_set_cmp_func(                                                    \

  2710.            CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk),         \

  2711.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a,  \

  2712.                                                 const X509_EXTENSION **b), \

  2713.                         comp)))

  2714. 

  2715. #define sk_X509_EXTENSION_deep_copy(sk, copy_func, free_func)                \

  2716.   ((STACK_OF(X509_EXTENSION) *)sk_deep_copy(                                 \

  2717.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk),    \

  2718.       CHECKED_CAST(void *(*)(void *), X509_EXTENSION *(*)(X509_EXTENSION *), \

  2719.                    copy_func),                                               \

  2720.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func)))

  2721. 

  2722. /* X509_INFO */

  2723. #define sk_X509_INFO_new(comp)     \

  2724.   ((STACK_OF(X509_INFO) *)sk_new(  \

  2725.       CHECKED_CAST(stack_cmp_func, \

  2726.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2727. 

  2728. #define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null())

  2729. 

  2730. #define sk_X509_INFO_num(sk) \

  2731.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))

  2732. 

  2733. #define sk_X509_INFO_zero(sk) \

  2734.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));

  2735. 

  2736. #define sk_X509_INFO_value(sk, i) \

  2737.   ((X509_INFO *)sk_value(         \

  2738.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk), (i)))

  2739. 

  2740. #define sk_X509_INFO_set(sk, i, p)                                             \

  2741.   ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \

  2742.                        CHECKED_CAST(void *, X509_INFO *, p)))

  2743. 

  2744. #define sk_X509_INFO_free(sk) \

  2745.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2746. 

  2747. #define sk_X509_INFO_pop_free(sk, free_func)             \

  2748.   sk_pop_free(                                           \

  2749.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2750.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))

  2751. 

  2752. #define sk_X509_INFO_insert(sk, p, where)                      \

  2753.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2754.             CHECKED_CAST(void *, X509_INFO *, p), (where))

  2755. 

  2756. #define sk_X509_INFO_delete(sk, where)                                       \

  2757.   ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2758.                           (where)))

  2759. 

  2760. #define sk_X509_INFO_delete_ptr(sk, p)                   \

  2761.   ((X509_INFO *)sk_delete_ptr(                           \

  2762.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2763.       CHECKED_CAST(void *, X509_INFO *, p)))

  2764. 

  2765. #define sk_X509_INFO_find(sk, out_index, p)                               \

  2766.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \

  2767.           CHECKED_CAST(void *, X509_INFO *, p))

  2768. 

  2769. #define sk_X509_INFO_shift(sk) \

  2770.   ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2771. 

  2772. #define sk_X509_INFO_push(sk, p)                             \

  2773.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2774.           CHECKED_CAST(void *, X509_INFO *, p))

  2775. 

  2776. #define sk_X509_INFO_pop(sk) \

  2777.   ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2778. 

  2779. #define sk_X509_INFO_dup(sk)      \

  2780.   ((STACK_OF(X509_INFO) *)sk_dup( \

  2781.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk)))

  2782. 

  2783. #define sk_X509_INFO_sort(sk) \

  2784.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2785. 

  2786. #define sk_X509_INFO_is_sorted(sk) \

  2787.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))

  2788. 

  2789. #define sk_X509_INFO_set_cmp_func(sk, comp)                            \

  2790.   ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \

  2791.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk),               \

  2792.       CHECKED_CAST(stack_cmp_func,                                     \

  2793.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2794. 

  2795. #define sk_X509_INFO_deep_copy(sk, copy_func, free_func)                       \

  2796.   ((STACK_OF(X509_INFO) *)sk_deep_copy(                                        \

  2797.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk),           \

  2798.       CHECKED_CAST(void *(*)(void *), X509_INFO *(*)(X509_INFO *), copy_func), \

  2799.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func)))

  2800. 

  2801. /* X509_LOOKUP */

  2802. #define sk_X509_LOOKUP_new(comp)                                             \

  2803.   ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST(                             \

  2804.       stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \

  2805.       comp)))

  2806. 

  2807. #define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null())

  2808. 

  2809. #define sk_X509_LOOKUP_num(sk) \

  2810.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))

  2811. 

  2812. #define sk_X509_LOOKUP_zero(sk) \

  2813.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));

  2814. 

  2815. #define sk_X509_LOOKUP_value(sk, i) \

  2816.   ((X509_LOOKUP *)sk_value(         \

  2817.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))

  2818. 

  2819. #define sk_X509_LOOKUP_set(sk, i, p)                                          \

  2820.   ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2821.                          (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2822. 

  2823. #define sk_X509_LOOKUP_free(sk) \

  2824.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2825. 

  2826. #define sk_X509_LOOKUP_pop_free(sk, free_func)             \

  2827.   sk_pop_free(                                             \

  2828.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2829.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))

  2830. 

  2831. #define sk_X509_LOOKUP_insert(sk, p, where)                      \

  2832.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2833.             CHECKED_CAST(void *, X509_LOOKUP *, p), (where))

  2834. 

  2835. #define sk_X509_LOOKUP_delete(sk, where) \

  2836.   ((X509_LOOKUP *)sk_delete(             \

  2837.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))

  2838. 

  2839. #define sk_X509_LOOKUP_delete_ptr(sk, p)                   \

  2840.   ((X509_LOOKUP *)sk_delete_ptr(                           \

  2841.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2842.       CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2843. 

  2844. #define sk_X509_LOOKUP_find(sk, out_index, p)                               \

  2845.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \

  2846.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2847. 

  2848. #define sk_X509_LOOKUP_shift(sk) \

  2849.   ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2850. 

  2851. #define sk_X509_LOOKUP_push(sk, p)                             \

  2852.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2853.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2854. 

  2855. #define sk_X509_LOOKUP_pop(sk) \

  2856.   ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2857. 

  2858. #define sk_X509_LOOKUP_dup(sk)      \

  2859.   ((STACK_OF(X509_LOOKUP) *)sk_dup( \

  2860.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk)))

  2861. 

  2862. #define sk_X509_LOOKUP_sort(sk) \

  2863.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2864. 

  2865. #define sk_X509_LOOKUP_is_sorted(sk) \

  2866.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))

  2867. 

  2868. #define sk_X509_LOOKUP_set_cmp_func(sk, comp)                              \

  2869.   ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \

  2870.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk),                 \

  2871.       CHECKED_CAST(stack_cmp_func,                                         \

  2872.                    int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b),  \

  2873.                    comp)))

  2874. 

  2875. #define sk_X509_LOOKUP_deep_copy(sk, copy_func, free_func)             \

  2876.   ((STACK_OF(X509_LOOKUP) *)sk_deep_copy(                              \

  2877.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), \

  2878.       CHECKED_CAST(void *(*)(void *), X509_LOOKUP *(*)(X509_LOOKUP *), \

  2879.                    copy_func),                                         \

  2880.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func)))

  2881. 

  2882. /* X509_NAME */

  2883. #define sk_X509_NAME_new(comp)     \

  2884.   ((STACK_OF(X509_NAME) *)sk_new(  \

  2885.       CHECKED_CAST(stack_cmp_func, \

  2886.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2887. 

  2888. #define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null())

  2889. 

  2890. #define sk_X509_NAME_num(sk) \

  2891.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))

  2892. 

  2893. #define sk_X509_NAME_zero(sk) \

  2894.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));

  2895. 

  2896. #define sk_X509_NAME_value(sk, i) \

  2897.   ((X509_NAME *)sk_value(         \

  2898.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk), (i)))

  2899. 

  2900. #define sk_X509_NAME_set(sk, i, p)                                             \

  2901.   ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \

  2902.                        CHECKED_CAST(void *, X509_NAME *, p)))

  2903. 

  2904. #define sk_X509_NAME_free(sk) \

  2905.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2906. 

  2907. #define sk_X509_NAME_pop_free(sk, free_func)             \

  2908.   sk_pop_free(                                           \

  2909.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2910.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))

  2911. 

  2912. #define sk_X509_NAME_insert(sk, p, where)                      \

  2913.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2914.             CHECKED_CAST(void *, X509_NAME *, p), (where))

  2915. 

  2916. #define sk_X509_NAME_delete(sk, where)                                       \

  2917.   ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2918.                           (where)))

  2919. 

  2920. #define sk_X509_NAME_delete_ptr(sk, p)                   \

  2921.   ((X509_NAME *)sk_delete_ptr(                           \

  2922.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2923.       CHECKED_CAST(void *, X509_NAME *, p)))

  2924. 

  2925. #define sk_X509_NAME_find(sk, out_index, p)                               \

  2926.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \

  2927.           CHECKED_CAST(void *, X509_NAME *, p))

  2928. 

  2929. #define sk_X509_NAME_shift(sk) \

  2930.   ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2931. 

  2932. #define sk_X509_NAME_push(sk, p)                             \

  2933.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2934.           CHECKED_CAST(void *, X509_NAME *, p))

  2935. 

  2936. #define sk_X509_NAME_pop(sk) \

  2937.   ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2938. 

  2939. #define sk_X509_NAME_dup(sk)      \

  2940.   ((STACK_OF(X509_NAME) *)sk_dup( \

  2941.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk)))

  2942. 

  2943. #define sk_X509_NAME_sort(sk) \

  2944.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2945. 

  2946. #define sk_X509_NAME_is_sorted(sk) \

  2947.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))

  2948. 

  2949. #define sk_X509_NAME_set_cmp_func(sk, comp)                            \

  2950.   ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \

  2951.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk),               \

  2952.       CHECKED_CAST(stack_cmp_func,                                     \

  2953.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2954. 

  2955. #define sk_X509_NAME_deep_copy(sk, copy_func, free_func)                       \

  2956.   ((STACK_OF(X509_NAME) *)sk_deep_copy(                                        \

  2957.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk),           \

  2958.       CHECKED_CAST(void *(*)(void *), X509_NAME *(*)(X509_NAME *), copy_func), \

  2959.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func)))

  2960. 

  2961. /* X509_NAME_ENTRY */

  2962. #define sk_X509_NAME_ENTRY_new(comp)                 \

  2963.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \

  2964.       stack_cmp_func,                                \

  2965.       int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))

  2966. 

  2967. #define sk_X509_NAME_ENTRY_new_null() \

  2968.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())

  2969. 

  2970. #define sk_X509_NAME_ENTRY_num(sk) \

  2971.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

  2972. 

  2973. #define sk_X509_NAME_ENTRY_zero(sk) \

  2974.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));

  2975. 

  2976. #define sk_X509_NAME_ENTRY_value(sk, i)                                    \

  2977.   ((X509_NAME_ENTRY *)sk_value(                                            \

  2978.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), \

  2979.       (i)))

  2980. 

  2981. #define sk_X509_NAME_ENTRY_set(sk, i, p)                            \

  2982.   ((X509_NAME_ENTRY *)sk_set(                                       \

  2983.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \

  2984.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  2985. 

  2986. #define sk_X509_NAME_ENTRY_free(sk) \

  2987.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2988. 

  2989. #define sk_X509_NAME_ENTRY_pop_free(sk, free_func)             \

  2990.   sk_pop_free(                                                 \

  2991.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2992.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))

  2993. 

  2994. #define sk_X509_NAME_ENTRY_insert(sk, p, where)                      \

  2995.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2996.             CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))

  2997. 

  2998. #define sk_X509_NAME_ENTRY_delete(sk, where) \

  2999.   ((X509_NAME_ENTRY *)sk_delete(             \

  3000.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))

  3001. 

  3002. #define sk_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  3003.   ((X509_NAME_ENTRY *)sk_delete_ptr(                           \

  3004.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3005.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  3006. 

  3007. #define sk_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  3008.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3009.           (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  3010. 

  3011. #define sk_X509_NAME_ENTRY_shift(sk) \

  3012.   ((X509_NAME_ENTRY *)sk_shift(      \

  3013.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  3014. 

  3015. #define sk_X509_NAME_ENTRY_push(sk, p)                             \

  3016.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  3017.           CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  3018. 

  3019. #define sk_X509_NAME_ENTRY_pop(sk) \

  3020.   ((X509_NAME_ENTRY *)sk_pop(      \

  3021.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  3022. 

  3023. #define sk_X509_NAME_ENTRY_dup(sk)      \

  3024.   ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \

  3025.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))

  3026. 

  3027. #define sk_X509_NAME_ENTRY_sort(sk) \

  3028.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  3029. 

  3030. #define sk_X509_NAME_ENTRY_is_sorted(sk) \

  3031.   sk_is_sorted(                          \

  3032.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

  3033. 

  3034. #define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp)                           \

  3035.   ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b))          \

  3036.        sk_set_cmp_func(                                                     \

  3037.            CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk),         \

  3038.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a,  \

  3039.                                                 const X509_NAME_ENTRY **b), \

  3040.                         comp)))

  3041. 

  3042. #define sk_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)                 \

  3043.   ((STACK_OF(X509_NAME_ENTRY) *)sk_deep_copy(                                  \

  3044.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk),     \

  3045.       CHECKED_CAST(void *(*)(void *), X509_NAME_ENTRY *(*)(X509_NAME_ENTRY *), \

  3046.                    copy_func),                                                 \

  3047.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func)))

  3048. 

  3049. /* X509_OBJECT */

  3050. #define sk_X509_OBJECT_new(comp)                                             \

  3051.   ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST(                             \

  3052.       stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \

  3053.       comp)))

  3054. 

  3055. #define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null())

  3056. 

  3057. #define sk_X509_OBJECT_num(sk) \

  3058.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))

  3059. 

  3060. #define sk_X509_OBJECT_zero(sk) \

  3061.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));

  3062. 

  3063. #define sk_X509_OBJECT_value(sk, i) \

  3064.   ((X509_OBJECT *)sk_value(         \

  3065.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))

  3066. 

  3067. #define sk_X509_OBJECT_set(sk, i, p)                                          \

  3068.   ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3069.                          (i), CHECKED_CAST(void *, X509_OBJECT *, p)))

  3070. 

  3071. #define sk_X509_OBJECT_free(sk) \

  3072.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  3073. 

  3074. #define sk_X509_OBJECT_pop_free(sk, free_func)             \

  3075.   sk_pop_free(                                             \

  3076.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3077.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))

  3078. 

  3079. #define sk_X509_OBJECT_insert(sk, p, where)                      \

  3080.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3081.             CHECKED_CAST(void *, X509_OBJECT *, p), (where))

  3082. 

  3083. #define sk_X509_OBJECT_delete(sk, where) \

  3084.   ((X509_OBJECT *)sk_delete(             \

  3085.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))

  3086. 

  3087. #define sk_X509_OBJECT_delete_ptr(sk, p)                   \

  3088.   ((X509_OBJECT *)sk_delete_ptr(                           \

  3089.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3090.       CHECKED_CAST(void *, X509_OBJECT *, p)))

  3091. 

  3092. #define sk_X509_OBJECT_find(sk, out_index, p)                               \

  3093.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \

  3094.           CHECKED_CAST(void *, X509_OBJECT *, p))

  3095. 

  3096. #define sk_X509_OBJECT_shift(sk) \

  3097.   ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  3098. 

  3099. #define sk_X509_OBJECT_push(sk, p)                             \

  3100.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  3101.           CHECKED_CAST(void *, X509_OBJECT *, p))

  3102. 

  3103. #define sk_X509_OBJECT_pop(sk) \

  3104.   ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  3105. 

  3106. #define sk_X509_OBJECT_dup(sk)      \

  3107.   ((STACK_OF(X509_OBJECT) *)sk_dup( \

  3108.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk)))

  3109. 

  3110. #define sk_X509_OBJECT_sort(sk) \

  3111.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  3112. 

  3113. #define sk_X509_OBJECT_is_sorted(sk) \

  3114.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))

  3115. 

  3116. #define sk_X509_OBJECT_set_cmp_func(sk, comp)                              \

  3117.   ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \

  3118.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk),                 \

  3119.       CHECKED_CAST(stack_cmp_func,                                         \

  3120.                    int (*)(const X509_OBJECT **a, const X509_OBJECT **b),  \

  3121.                    comp)))

  3122. 

  3123. #define sk_X509_OBJECT_deep_copy(sk, copy_func, free_func)             \

  3124.   ((STACK_OF(X509_OBJECT) *)sk_deep_copy(                              \

  3125.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), \

  3126.       CHECKED_CAST(void *(*)(void *), X509_OBJECT *(*)(X509_OBJECT *), \

  3127.                    copy_func),                                         \

  3128.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func)))

  3129. 

  3130. /* X509_POLICY_DATA */

  3131. #define sk_X509_POLICY_DATA_new(comp)                 \

  3132.   ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \

  3133.       stack_cmp_func,                                 \

  3134.       int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))

  3135. 

  3136. #define sk_X509_POLICY_DATA_new_null() \

  3137.   ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())

  3138. 

  3139. #define sk_X509_POLICY_DATA_num(sk) \

  3140.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

  3141. 

  3142. #define sk_X509_POLICY_DATA_zero(sk) \

  3143.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));

  3144. 

  3145. #define sk_X509_POLICY_DATA_value(sk, i)                                    \

  3146.   ((X509_POLICY_DATA *)sk_value(                                            \

  3147.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \

  3148.       (i)))

  3149. 

  3150. #define sk_X509_POLICY_DATA_set(sk, i, p)                            \

  3151.   ((X509_POLICY_DATA *)sk_set(                                       \

  3152.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \

  3153.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3154. 

  3155. #define sk_X509_POLICY_DATA_free(sk) \

  3156.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3157. 

  3158. #define sk_X509_POLICY_DATA_pop_free(sk, free_func)             \

  3159.   sk_pop_free(                                                  \

  3160.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3161.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))

  3162. 

  3163. #define sk_X509_POLICY_DATA_insert(sk, p, where)                      \

  3164.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3165.             CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))

  3166. 

  3167. #define sk_X509_POLICY_DATA_delete(sk, where) \

  3168.   ((X509_POLICY_DATA *)sk_delete(             \

  3169.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))

  3170. 

  3171. #define sk_X509_POLICY_DATA_delete_ptr(sk, p)                   \

  3172.   ((X509_POLICY_DATA *)sk_delete_ptr(                           \

  3173.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3174.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  3175. 

  3176. #define sk_X509_POLICY_DATA_find(sk, out_index, p)                  \

  3177.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3178.           (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3179. 

  3180. #define sk_X509_POLICY_DATA_shift(sk) \

  3181.   ((X509_POLICY_DATA *)sk_shift(      \

  3182.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3183. 

  3184. #define sk_X509_POLICY_DATA_push(sk, p)                             \

  3185.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  3186.           CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  3187. 

  3188. #define sk_X509_POLICY_DATA_pop(sk) \

  3189.   ((X509_POLICY_DATA *)sk_pop(      \

  3190.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  3191. 

  3192. #define sk_X509_POLICY_DATA_dup(sk)      \

  3193.   ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \

  3194.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))

  3195. 

  3196. #define sk_X509_POLICY_DATA_sort(sk) \

  3197.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  3198. 

  3199. #define sk_X509_POLICY_DATA_is_sorted(sk) \

  3200.   sk_is_sorted(                           \

  3201.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

  3202. 

  3203. #define sk_X509_POLICY_DATA_set_cmp_func(sk, comp)                           \

  3204.   ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b))         \

  3205.        sk_set_cmp_func(                                                      \

  3206.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk),         \

  3207.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a,  \

  3208.                                                 const X509_POLICY_DATA **b), \

  3209.                         comp)))

  3210. 

  3211. #define sk_X509_POLICY_DATA_deep_copy(sk, copy_func, free_func)             \

  3212.   ((STACK_OF(X509_POLICY_DATA) *)sk_deep_copy(                              \

  3213.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \

  3214.       CHECKED_CAST(void *(*)(void *),                                       \

  3215.                    X509_POLICY_DATA *(*)(X509_POLICY_DATA *), copy_func),   \

  3216.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *),          \

  3217.                    free_func)))

  3218. 

  3219. /* X509_POLICY_NODE */

  3220. #define sk_X509_POLICY_NODE_new(comp)                 \

  3221.   ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \

  3222.       stack_cmp_func,                                 \

  3223.       int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))

  3224. 

  3225. #define sk_X509_POLICY_NODE_new_null() \

  3226.   ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())

  3227. 

  3228. #define sk_X509_POLICY_NODE_num(sk) \

  3229.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

  3230. 

  3231. #define sk_X509_POLICY_NODE_zero(sk) \

  3232.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));

  3233. 

  3234. #define sk_X509_POLICY_NODE_value(sk, i)                                    \

  3235.   ((X509_POLICY_NODE *)sk_value(                                            \

  3236.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \

  3237.       (i)))

  3238. 

  3239. #define sk_X509_POLICY_NODE_set(sk, i, p)                            \

  3240.   ((X509_POLICY_NODE *)sk_set(                                       \

  3241.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \

  3242.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3243. 

  3244. #define sk_X509_POLICY_NODE_free(sk) \

  3245.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3246. 

  3247. #define sk_X509_POLICY_NODE_pop_free(sk, free_func)             \

  3248.   sk_pop_free(                                                  \

  3249.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3250.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))

  3251. 

  3252. #define sk_X509_POLICY_NODE_insert(sk, p, where)                      \

  3253.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3254.             CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))

  3255. 

  3256. #define sk_X509_POLICY_NODE_delete(sk, where) \

  3257.   ((X509_POLICY_NODE *)sk_delete(             \

  3258.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))

  3259. 

  3260. #define sk_X509_POLICY_NODE_delete_ptr(sk, p)                   \

  3261.   ((X509_POLICY_NODE *)sk_delete_ptr(                           \

  3262.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3263.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  3264. 

  3265. #define sk_X509_POLICY_NODE_find(sk, out_index, p)                  \

  3266.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3267.           (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3268. 

  3269. #define sk_X509_POLICY_NODE_shift(sk) \

  3270.   ((X509_POLICY_NODE *)sk_shift(      \

  3271.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3272. 

  3273. #define sk_X509_POLICY_NODE_push(sk, p)                             \

  3274.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  3275.           CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  3276. 

  3277. #define sk_X509_POLICY_NODE_pop(sk) \

  3278.   ((X509_POLICY_NODE *)sk_pop(      \

  3279.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  3280. 

  3281. #define sk_X509_POLICY_NODE_dup(sk)      \

  3282.   ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \

  3283.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))

  3284. 

  3285. #define sk_X509_POLICY_NODE_sort(sk) \

  3286.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  3287. 

  3288. #define sk_X509_POLICY_NODE_is_sorted(sk) \

  3289.   sk_is_sorted(                           \

  3290.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

  3291. 

  3292. #define sk_X509_POLICY_NODE_set_cmp_func(sk, comp)                           \

  3293.   ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b))         \

  3294.        sk_set_cmp_func(                                                      \

  3295.            CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk),         \

  3296.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a,  \

  3297.                                                 const X509_POLICY_NODE **b), \

  3298.                         comp)))

  3299. 

  3300. #define sk_X509_POLICY_NODE_deep_copy(sk, copy_func, free_func)             \

  3301.   ((STACK_OF(X509_POLICY_NODE) *)sk_deep_copy(                              \

  3302.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \

  3303.       CHECKED_CAST(void *(*)(void *),                                       \

  3304.                    X509_POLICY_NODE *(*)(X509_POLICY_NODE *), copy_func),   \

  3305.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *),          \

  3306.                    free_func)))

  3307. 

  3308. /* X509_PURPOSE */

  3309. #define sk_X509_PURPOSE_new(comp)                                              \

  3310.   ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST(                              \

  3311.       stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \

  3312.       comp)))

  3313. 

  3314. #define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null())

  3315. 

  3316. #define sk_X509_PURPOSE_num(sk) \

  3317.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))

  3318. 

  3319. #define sk_X509_PURPOSE_zero(sk) \

  3320.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));

  3321. 

  3322. #define sk_X509_PURPOSE_value(sk, i) \

  3323.   ((X509_PURPOSE *)sk_value(         \

  3324.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))

  3325. 

  3326. #define sk_X509_PURPOSE_set(sk, i, p)                            \

  3327.   ((X509_PURPOSE *)sk_set(                                       \

  3328.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \

  3329.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3330. 

  3331. #define sk_X509_PURPOSE_free(sk) \

  3332.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3333. 

  3334. #define sk_X509_PURPOSE_pop_free(sk, free_func)             \

  3335.   sk_pop_free(                                              \

  3336.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3337.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))

  3338. 

  3339. #define sk_X509_PURPOSE_insert(sk, p, where)                      \

  3340.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3341.             CHECKED_CAST(void *, X509_PURPOSE *, p), (where))

  3342. 

  3343. #define sk_X509_PURPOSE_delete(sk, where) \

  3344.   ((X509_PURPOSE *)sk_delete(             \

  3345.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))

  3346. 

  3347. #define sk_X509_PURPOSE_delete_ptr(sk, p)                   \

  3348.   ((X509_PURPOSE *)sk_delete_ptr(                           \

  3349.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3350.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3351. 

  3352. #define sk_X509_PURPOSE_find(sk, out_index, p)                               \

  3353.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \

  3354.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3355. 

  3356. #define sk_X509_PURPOSE_shift(sk) \

  3357.   ((X509_PURPOSE *)sk_shift(      \

  3358.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3359. 

  3360. #define sk_X509_PURPOSE_push(sk, p)                             \

  3361.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3362.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3363. 

  3364. #define sk_X509_PURPOSE_pop(sk) \

  3365.   ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3366. 

  3367. #define sk_X509_PURPOSE_dup(sk)      \

  3368.   ((STACK_OF(X509_PURPOSE) *)sk_dup( \

  3369.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk)))

  3370. 

  3371. #define sk_X509_PURPOSE_sort(sk) \

  3372.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3373. 

  3374. #define sk_X509_PURPOSE_is_sorted(sk) \

  3375.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))

  3376. 

  3377. #define sk_X509_PURPOSE_set_cmp_func(sk, comp)                               \

  3378.   ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \

  3379.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk),                  \

  3380.       CHECKED_CAST(stack_cmp_func,                                           \

  3381.                    int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b),  \

  3382.                    comp)))

  3383. 

  3384. #define sk_X509_PURPOSE_deep_copy(sk, copy_func, free_func)              \

  3385.   ((STACK_OF(X509_PURPOSE) *)sk_deep_copy(                               \

  3386.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk),  \

  3387.       CHECKED_CAST(void *(*)(void *), X509_PURPOSE *(*)(X509_PURPOSE *), \

  3388.                    copy_func),                                           \

  3389.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func)))

  3390. 

  3391. /* X509_REVOKED */

  3392. #define sk_X509_REVOKED_new(comp)                                              \

  3393.   ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST(                              \

  3394.       stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \

  3395.       comp)))

  3396. 

  3397. #define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null())

  3398. 

  3399. #define sk_X509_REVOKED_num(sk) \

  3400.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))

  3401. 

  3402. #define sk_X509_REVOKED_zero(sk) \

  3403.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));

  3404. 

  3405. #define sk_X509_REVOKED_value(sk, i) \

  3406.   ((X509_REVOKED *)sk_value(         \

  3407.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))

  3408. 

  3409. #define sk_X509_REVOKED_set(sk, i, p)                            \

  3410.   ((X509_REVOKED *)sk_set(                                       \

  3411.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \

  3412.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3413. 

  3414. #define sk_X509_REVOKED_free(sk) \

  3415.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3416. 

  3417. #define sk_X509_REVOKED_pop_free(sk, free_func)             \

  3418.   sk_pop_free(                                              \

  3419.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3420.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))

  3421. 

  3422. #define sk_X509_REVOKED_insert(sk, p, where)                      \

  3423.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3424.             CHECKED_CAST(void *, X509_REVOKED *, p), (where))

  3425. 

  3426. #define sk_X509_REVOKED_delete(sk, where) \

  3427.   ((X509_REVOKED *)sk_delete(             \

  3428.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))

  3429. 

  3430. #define sk_X509_REVOKED_delete_ptr(sk, p)                   \

  3431.   ((X509_REVOKED *)sk_delete_ptr(                           \

  3432.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3433.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3434. 

  3435. #define sk_X509_REVOKED_find(sk, out_index, p)                               \

  3436.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \

  3437.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3438. 

  3439. #define sk_X509_REVOKED_shift(sk) \

  3440.   ((X509_REVOKED *)sk_shift(      \

  3441.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3442. 

  3443. #define sk_X509_REVOKED_push(sk, p)                             \

  3444.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3445.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3446. 

  3447. #define sk_X509_REVOKED_pop(sk) \

  3448.   ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3449. 

  3450. #define sk_X509_REVOKED_dup(sk)      \

  3451.   ((STACK_OF(X509_REVOKED) *)sk_dup( \

  3452.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk)))

  3453. 

  3454. #define sk_X509_REVOKED_sort(sk) \

  3455.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3456. 

  3457. #define sk_X509_REVOKED_is_sorted(sk) \

  3458.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))

  3459. 

  3460. #define sk_X509_REVOKED_set_cmp_func(sk, comp)                               \

  3461.   ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \

  3462.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk),                  \

  3463.       CHECKED_CAST(stack_cmp_func,                                           \

  3464.                    int (*)(const X509_REVOKED **a, const X509_REVOKED **b),  \

  3465.                    comp)))

  3466. 

  3467. #define sk_X509_REVOKED_deep_copy(sk, copy_func, free_func)              \

  3468.   ((STACK_OF(X509_REVOKED) *)sk_deep_copy(                               \

  3469.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk),  \

  3470.       CHECKED_CAST(void *(*)(void *), X509_REVOKED *(*)(X509_REVOKED *), \

  3471.                    copy_func),                                           \

  3472.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func)))

  3473. 

  3474. /* X509_TRUST */

  3475. #define sk_X509_TRUST_new(comp)                                            \

  3476.   ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST(                            \

  3477.       stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \

  3478.       comp)))

  3479. 

  3480. #define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null())

  3481. 

  3482. #define sk_X509_TRUST_num(sk) \

  3483.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))

  3484. 

  3485. #define sk_X509_TRUST_zero(sk) \

  3486.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));

  3487. 

  3488. #define sk_X509_TRUST_value(sk, i) \

  3489.   ((X509_TRUST *)sk_value(         \

  3490.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))

  3491. 

  3492. #define sk_X509_TRUST_set(sk, i, p)                                         \

  3493.   ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3494.                         (i), CHECKED_CAST(void *, X509_TRUST *, p)))

  3495. 

  3496. #define sk_X509_TRUST_free(sk) \

  3497.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3498. 

  3499. #define sk_X509_TRUST_pop_free(sk, free_func)             \

  3500.   sk_pop_free(                                            \

  3501.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3502.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))

  3503. 

  3504. #define sk_X509_TRUST_insert(sk, p, where)                      \

  3505.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3506.             CHECKED_CAST(void *, X509_TRUST *, p), (where))

  3507. 

  3508. #define sk_X509_TRUST_delete(sk, where)                                        \

  3509.   ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3510.                            (where)))

  3511. 

  3512. #define sk_X509_TRUST_delete_ptr(sk, p)                   \

  3513.   ((X509_TRUST *)sk_delete_ptr(                           \

  3514.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3515.       CHECKED_CAST(void *, X509_TRUST *, p)))

  3516. 

  3517. #define sk_X509_TRUST_find(sk, out_index, p)                               \

  3518.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \

  3519.           CHECKED_CAST(void *, X509_TRUST *, p))

  3520. 

  3521. #define sk_X509_TRUST_shift(sk) \

  3522.   ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3523. 

  3524. #define sk_X509_TRUST_push(sk, p)                             \

  3525.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3526.           CHECKED_CAST(void *, X509_TRUST *, p))

  3527. 

  3528. #define sk_X509_TRUST_pop(sk) \

  3529.   ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3530. 

  3531. #define sk_X509_TRUST_dup(sk)      \

  3532.   ((STACK_OF(X509_TRUST) *)sk_dup( \

  3533.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk)))

  3534. 

  3535. #define sk_X509_TRUST_sort(sk) \

  3536.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3537. 

  3538. #define sk_X509_TRUST_is_sorted(sk) \

  3539.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))

  3540. 

  3541. #define sk_X509_TRUST_set_cmp_func(sk, comp)                             \

  3542.   ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \

  3543.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk),                \

  3544.       CHECKED_CAST(stack_cmp_func,                                       \

  3545.                    int (*)(const X509_TRUST **a, const X509_TRUST **b),  \

  3546.                    comp)))

  3547. 

  3548. #define sk_X509_TRUST_deep_copy(sk, copy_func, free_func)             \

  3549.   ((STACK_OF(X509_TRUST) *)sk_deep_copy(                              \

  3550.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), \

  3551.       CHECKED_CAST(void *(*)(void *), X509_TRUST *(*)(X509_TRUST *),  \

  3552.                    copy_func),                                        \

  3553.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func)))

  3554. 

  3555. /* X509_VERIFY_PARAM */

  3556. #define sk_X509_VERIFY_PARAM_new(comp)                                   \

  3557.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST(                   \

  3558.       stack_cmp_func,                                                    \

  3559.       int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \

  3560.       comp)))

  3561. 

  3562. #define sk_X509_VERIFY_PARAM_new_null() \

  3563.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())

  3564. 

  3565. #define sk_X509_VERIFY_PARAM_num(sk) \

  3566.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

  3567. 

  3568. #define sk_X509_VERIFY_PARAM_zero(sk) \

  3569.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));

  3570. 

  3571. #define sk_X509_VERIFY_PARAM_value(sk, i)                                    \

  3572.   ((X509_VERIFY_PARAM *)sk_value(                                            \

  3573.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3574.       (i)))

  3575. 

  3576. #define sk_X509_VERIFY_PARAM_set(sk, i, p)                            \

  3577.   ((X509_VERIFY_PARAM *)sk_set(                                       \

  3578.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \

  3579.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3580. 

  3581. #define sk_X509_VERIFY_PARAM_free(sk) \

  3582.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3583. 

  3584. #define sk_X509_VERIFY_PARAM_pop_free(sk, free_func)                        \

  3585.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),    \

  3586.               CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \

  3587.                            free_func))

  3588. 

  3589. #define sk_X509_VERIFY_PARAM_insert(sk, p, where)                      \

  3590.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3591.             CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))

  3592. 

  3593. #define sk_X509_VERIFY_PARAM_delete(sk, where) \

  3594.   ((X509_VERIFY_PARAM *)sk_delete(             \

  3595.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))

  3596. 

  3597. #define sk_X509_VERIFY_PARAM_delete_ptr(sk, p)                   \

  3598.   ((X509_VERIFY_PARAM *)sk_delete_ptr(                           \

  3599.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3600.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3601. 

  3602. #define sk_X509_VERIFY_PARAM_find(sk, out_index, p)                  \

  3603.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3604.           (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3605. 

  3606. #define sk_X509_VERIFY_PARAM_shift(sk) \

  3607.   ((X509_VERIFY_PARAM *)sk_shift(      \

  3608.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3609. 

  3610. #define sk_X509_VERIFY_PARAM_push(sk, p)                             \

  3611.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3612.           CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3613. 

  3614. #define sk_X509_VERIFY_PARAM_pop(sk) \

  3615.   ((X509_VERIFY_PARAM *)sk_pop(      \

  3616.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3617. 

  3618. #define sk_X509_VERIFY_PARAM_dup(sk)      \

  3619.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \

  3620.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3621. 

  3622. #define sk_X509_VERIFY_PARAM_sort(sk) \

  3623.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3624. 

  3625. #define sk_X509_VERIFY_PARAM_is_sorted(sk) \

  3626.   sk_is_sorted(                            \

  3627.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

  3628. 

  3629. #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp)                           \

  3630.   ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b))        \

  3631.        sk_set_cmp_func(                                                       \

  3632.            CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),         \

  3633.            CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a,  \

  3634.                                                 const X509_VERIFY_PARAM **b), \

  3635.                         comp)))

  3636. 

  3637. #define sk_X509_VERIFY_PARAM_deep_copy(sk, copy_func, free_func)             \

  3638.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_deep_copy(                              \

  3639.       CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3640.       CHECKED_CAST(void *(*)(void *),                                        \

  3641.                    X509_VERIFY_PARAM *(*)(X509_VERIFY_PARAM *), copy_func),  \

  3642.       CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *),          \

  3643.                    free_func)))

  3644. 

  3645. /* void */

  3646. #define sk_void_new(comp)                 \

  3647.   ((STACK_OF(void) *)sk_new(CHECKED_CAST( \

  3648.       stack_cmp_func, int (*)(const void **a, const void **b), comp)))

  3649. 

  3650. #define sk_void_new_null() ((STACK_OF(void) *)sk_new_null())

  3651. 

  3652. #define sk_void_num(sk) \

  3653.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))

  3654. 

  3655. #define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk));

  3656. 

  3657. #define sk_void_value(sk, i)                                                  \

  3658.   ((void *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk), \

  3659.                     (i)))

  3660. 

  3661. #define sk_void_set(sk, i, p)                                        \

  3662.   ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (i), \

  3663.                   CHECKED_CAST(void *, void *, p)))

  3664. 

  3665. #define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3666. 

  3667. #define sk_void_pop_free(sk, free_func)                     \

  3668.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3669.               CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))

  3670. 

  3671. #define sk_void_insert(sk, p, where)                      \

  3672.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3673.             CHECKED_CAST(void *, void *, p), (where))

  3674. 

  3675. #define sk_void_delete(sk, where) \

  3676.   ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (where)))

  3677. 

  3678. #define sk_void_delete_ptr(sk, p)                                      \

  3679.   ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3680.                          CHECKED_CAST(void *, void *, p)))

  3681. 

  3682. #define sk_void_find(sk, out_index, p)                               \

  3683.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (out_index), \

  3684.           CHECKED_CAST(void *, void *, p))

  3685. 

  3686. #define sk_void_shift(sk) \

  3687.   ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))

  3688. 

  3689. #define sk_void_push(sk, p)                             \

  3690.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \

  3691.           CHECKED_CAST(void *, void *, p))

  3692. 

  3693. #define sk_void_pop(sk) \

  3694.   ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))

  3695. 

  3696. #define sk_void_dup(sk)      \

  3697.   ((STACK_OF(void) *)sk_dup( \

  3698.       CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk)))

  3699. 

  3700. #define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

  3701. 

  3702. #define sk_void_is_sorted(sk) \

  3703.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))

  3704. 

  3705. #define sk_void_set_cmp_func(sk, comp)                                      \

  3706.   ((int (*)(const void **a, const void **b))sk_set_cmp_func(                \

  3707.       CHECKED_CAST(_STACK *, STACK_OF(void) *, sk),                         \

  3708.       CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \

  3709.                    comp)))

  3710. 

  3711. #define sk_void_deep_copy(sk, copy_func, free_func)                  \

  3712.   ((STACK_OF(void) *)sk_deep_copy(                                   \

  3713.       CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk),      \

  3714.       CHECKED_CAST(void *(*)(void *), void *(*)(void *), copy_func), \

  3715.       CHECKED_CAST(void (*)(void *), void (*)(void *), free_func)))

  3716. 

  3717. /* SRTP_PROTECTION_PROFILE */

  3718. #define sk_SRTP_PROTECTION_PROFILE_new(comp)                            \

  3719.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST(            \

  3720.       stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a,  \

  3721.                               const const SRTP_PROTECTION_PROFILE **b), \

  3722.       comp)))

  3723. 

  3724. #define sk_SRTP_PROTECTION_PROFILE_new_null() \

  3725.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())

  3726. 

  3727. #define sk_SRTP_PROTECTION_PROFILE_num(sk) \

  3728.   sk_num(CHECKED_CAST(const _STACK *,      \

  3729.                       const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3730. 

  3731. #define sk_SRTP_PROTECTION_PROFILE_zero(sk) \

  3732.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));

  3733. 

  3734. #define sk_SRTP_PROTECTION_PROFILE_value(sk, i)                               \

  3735.   ((const SRTP_PROTECTION_PROFILE *)sk_value(                                 \

  3736.       CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \

  3737.                    sk),                                                       \

  3738.       (i)))

  3739. 

  3740. #define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p)                            \

  3741.   ((const SRTP_PROTECTION_PROFILE *)sk_set(                                 \

  3742.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \

  3743.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3744. 

  3745. #define sk_SRTP_PROTECTION_PROFILE_free(sk) \

  3746.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3747. 

  3748. #define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func)             \

  3749.   sk_pop_free(                                                         \

  3750.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3751.       CHECKED_CAST(void (*)(void *),                                   \

  3752.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func))

  3753. 

  3754. #define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where)                      \

  3755.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3756.             CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where))

  3757. 

  3758. #define sk_SRTP_PROTECTION_PROFILE_delete(sk, where)                   \

  3759.   ((const SRTP_PROTECTION_PROFILE *)sk_delete(                         \

  3760.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3761.       (where)))

  3762. 

  3763. #define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p)                   \

  3764.   ((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr(                     \

  3765.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3766.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3767. 

  3768. #define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p)                  \

  3769.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3770.           (out_index),                                                     \

  3771.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3772. 

  3773. #define sk_SRTP_PROTECTION_PROFILE_shift(sk)  \

  3774.   ((const SRTP_PROTECTION_PROFILE *)sk_shift( \

  3775.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3776. 

  3777. #define sk_SRTP_PROTECTION_PROFILE_push(sk, p)                             \

  3778.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3779.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3780. 

  3781. #define sk_SRTP_PROTECTION_PROFILE_pop(sk)  \

  3782.   ((const SRTP_PROTECTION_PROFILE *)sk_pop( \

  3783.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3784. 

  3785. #define sk_SRTP_PROTECTION_PROFILE_dup(sk)                   \

  3786.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup(CHECKED_CAST( \

  3787.       const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3788. 

  3789. #define sk_SRTP_PROTECTION_PROFILE_sort(sk) \

  3790.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3791. 

  3792. #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \

  3793.   sk_is_sorted(CHECKED_CAST(const _STACK *,      \

  3794.                             const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3795. 

  3796. #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp)                   \

  3797.   ((int (*)(const SRTP_PROTECTION_PROFILE **a,                              \

  3798.             const SRTP_PROTECTION_PROFILE **b))                             \

  3799.        sk_set_cmp_func(                                                     \

  3800.            CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3801.            CHECKED_CAST(stack_cmp_func,                                     \

  3802.                         int (*)(const SRTP_PROTECTION_PROFILE **a,          \

  3803.                                 const SRTP_PROTECTION_PROFILE **b),         \

  3804.                         comp)))

  3805. 

  3806. #define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copy_func, free_func)         \

  3807.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_deep_copy(                          \

  3808.       CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *,  \

  3809.                    sk),                                                        \

  3810.       CHECKED_CAST(                                                            \

  3811.           void *(*)(void *),                                                   \

  3812.           const SRTP_PROTECTION_PROFILE *(*)(const SRTP_PROTECTION_PROFILE *), \

  3813.           copy_func),                                                          \

  3814.       CHECKED_CAST(void (*)(void *),                                           \

  3815.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func)))

  3816. 

  3817. /* SSL_CIPHER */

  3818. #define sk_SSL_CIPHER_new(comp)                 \

  3819.   ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \

  3820.       stack_cmp_func,                           \

  3821.       int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp)))

  3822. 

  3823. #define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null())

  3824. 

  3825. #define sk_SSL_CIPHER_num(sk) \

  3826.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))

  3827. 

  3828. #define sk_SSL_CIPHER_zero(sk) \

  3829.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));

  3830. 

  3831. #define sk_SSL_CIPHER_value(sk, i) \

  3832.   ((const SSL_CIPHER *)sk_value(   \

  3833.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))

  3834. 

  3835. #define sk_SSL_CIPHER_set(sk, i, p)                            \

  3836.   ((const SSL_CIPHER *)sk_set(                                 \

  3837.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \

  3838.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3839. 

  3840. #define sk_SSL_CIPHER_free(sk) \

  3841.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3842. 

  3843. #define sk_SSL_CIPHER_pop_free(sk, free_func)             \

  3844.   sk_pop_free(                                            \

  3845.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3846.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func))

  3847. 

  3848. #define sk_SSL_CIPHER_insert(sk, p, where)                      \

  3849.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3850.             CHECKED_CAST(void *, const SSL_CIPHER *, p), (where))

  3851. 

  3852. #define sk_SSL_CIPHER_delete(sk, where) \

  3853.   ((const SSL_CIPHER *)sk_delete(       \

  3854.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where)))

  3855. 

  3856. #define sk_SSL_CIPHER_delete_ptr(sk, p)                   \

  3857.   ((const SSL_CIPHER *)sk_delete_ptr(                     \

  3858.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3859.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3860. 

  3861. #define sk_SSL_CIPHER_find(sk, out_index, p)                               \

  3862.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \

  3863.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3864. 

  3865. #define sk_SSL_CIPHER_shift(sk)  \

  3866.   ((const SSL_CIPHER *)sk_shift( \

  3867.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3868. 

  3869. #define sk_SSL_CIPHER_push(sk, p)                             \

  3870.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3871.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3872. 

  3873. #define sk_SSL_CIPHER_pop(sk)  \

  3874.   ((const SSL_CIPHER *)sk_pop( \

  3875.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3876. 

  3877. #define sk_SSL_CIPHER_dup(sk)      \

  3878.   ((STACK_OF(SSL_CIPHER) *)sk_dup( \

  3879.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk)))

  3880. 

  3881. #define sk_SSL_CIPHER_sort(sk) \

  3882.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3883. 

  3884. #define sk_SSL_CIPHER_is_sorted(sk) \

  3885.   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))

  3886. 

  3887. #define sk_SSL_CIPHER_set_cmp_func(sk, comp)                             \

  3888.   ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \

  3889.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk),                \

  3890.       CHECKED_CAST(stack_cmp_func,                                       \

  3891.                    int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b),  \

  3892.                    comp)))

  3893. 

  3894. #define sk_SSL_CIPHER_deep_copy(sk, copy_func, free_func)                 \

  3895.   ((STACK_OF(SSL_CIPHER) *)sk_deep_copy(                                  \

  3896.       CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk),     \

  3897.       CHECKED_CAST(void *(*)(void *),                                     \

  3898.                    const SSL_CIPHER *(*)(const SSL_CIPHER *), copy_func), \

  3899.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *),        \

  3900.                    free_func)))

  3901. 

  3902. /* OPENSSL_STRING */

  3903. #define sk_OPENSSL_STRING_new(comp)                 \

  3904.   ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \

  3905.       stack_cmp_func,                               \

  3906.       int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))

  3907. 

  3908. #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())

  3909. 

  3910. #define sk_OPENSSL_STRING_num(sk) \

  3911.   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

  3912. 

  3913. #define sk_OPENSSL_STRING_zero(sk) \

  3914.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));

  3915. 

  3916. #define sk_OPENSSL_STRING_value(sk, i)                                    \

  3917.   ((OPENSSL_STRING)sk_value(                                              \

  3918.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \

  3919.       (i)))

  3920. 

  3921. #define sk_OPENSSL_STRING_set(sk, i, p)                            \

  3922.   ((OPENSSL_STRING)sk_set(                                         \

  3923.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \

  3924.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3925. 

  3926. #define sk_OPENSSL_STRING_free(sk) \

  3927.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3928. 

  3929. #define sk_OPENSSL_STRING_pop_free(sk, free_func)             \

  3930.   sk_pop_free(                                                \

  3931.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3932.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))

  3933. 

  3934. #define sk_OPENSSL_STRING_insert(sk, p, where)                      \

  3935.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3936.             CHECKED_CAST(void *, OPENSSL_STRING, p), (where))

  3937. 

  3938. #define sk_OPENSSL_STRING_delete(sk, where) \

  3939.   ((OPENSSL_STRING)sk_delete(               \

  3940.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))

  3941. 

  3942. #define sk_OPENSSL_STRING_delete_ptr(sk, p)                   \

  3943.   ((OPENSSL_STRING)sk_delete_ptr(                             \

  3944.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3945.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3946. 

  3947. #define sk_OPENSSL_STRING_find(sk, out_index, p)                               \

  3948.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \

  3949.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3950. 

  3951. #define sk_OPENSSL_STRING_shift(sk) \

  3952.   ((OPENSSL_STRING)sk_shift(        \

  3953.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3954. 

  3955. #define sk_OPENSSL_STRING_push(sk, p)                             \

  3956.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3957.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3958. 

  3959. #define sk_OPENSSL_STRING_pop(sk) \

  3960.   ((OPENSSL_STRING)sk_pop(        \

  3961.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3962. 

  3963. #define sk_OPENSSL_STRING_dup(sk)      \

  3964.   ((STACK_OF(OPENSSL_STRING) *)sk_dup( \

  3965.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))

  3966. 

  3967. #define sk_OPENSSL_STRING_sort(sk) \

  3968.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3969. 

  3970. #define sk_OPENSSL_STRING_is_sorted(sk) \

  3971.   sk_is_sorted(                         \

  3972.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

  3973. 

  3974. #define sk_OPENSSL_STRING_set_cmp_func(sk, comp)                           \

  3975.   ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b))           \

  3976.        sk_set_cmp_func(                                                    \

  3977.            CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk),         \

  3978.            CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a,  \

  3979.                                                 const OPENSSL_STRING **b), \

  3980.                         comp)))

  3981. 

  3982. #define sk_OPENSSL_STRING_deep_copy(sk, copy_func, free_func)             \

  3983.   ((STACK_OF(OPENSSL_STRING) *)sk_deep_copy(                              \

  3984.       CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \

  3985.       CHECKED_CAST(void *(*)(void *), OPENSSL_STRING (*)(OPENSSL_STRING), \

  3986.                    copy_func),                                            \

  3987.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func)))