kris
/
boringssl
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
841 Commity
12 Gałęzie
38 MiB
 
 
 
 
 
 
Drzewo: 78e6978ab9
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '78e6978ab9'
${ noResults }
boringssl/include/openssl/stack_macros.h

3705 wiersze
159 KiB
Czysty Wina Historia 

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

  2.  *

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

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

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

  6.  *

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

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

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

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

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

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

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

  14. 

  15. #if !defined(IN_STACK_H)

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

  17. #endif

  18. 

  19. /* ACCESS_DESCRIPTION */

  20. #define sk_ACCESS_DESCRIPTION_new(comp)                                    \

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

  22.       stack_cmp_func,                                                      \

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

  24.       comp)))

  25. 

  26. #define sk_ACCESS_DESCRIPTION_new_null() \

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

  28. 

  29. #define sk_ACCESS_DESCRIPTION_num(sk) \

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

  31. 

  32. #define sk_ACCESS_DESCRIPTION_zero(sk) \

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

  34. 

  35. #define sk_ACCESS_DESCRIPTION_value(sk, i) \

  36.   ((ACCESS_DESCRIPTION *)sk_value(         \

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

  38. 

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

  40.   ((ACCESS_DESCRIPTION *)sk_set(                                       \

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

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

  43. 

  44. #define sk_ACCESS_DESCRIPTION_free(sk) \

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

  46. 

  47. #define sk_ACCESS_DESCRIPTION_pop_free(sk, free_func)                        \

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

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

  50.                            free_func))

  51. 

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

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

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

  55. 

  56. #define sk_ACCESS_DESCRIPTION_delete(sk, where) \

  57.   ((ACCESS_DESCRIPTION *)sk_delete(             \

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

  59. 

  60. #define sk_ACCESS_DESCRIPTION_delete_ptr(sk, p)                   \

  61.   ((ACCESS_DESCRIPTION *)sk_delete_ptr(                           \

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

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

  64. 

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

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

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

  68. 

  69. #define sk_ACCESS_DESCRIPTION_shift(sk) \

  70.   ((ACCESS_DESCRIPTION *)sk_shift(      \

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

  72. 

  73. #define sk_ACCESS_DESCRIPTION_push(sk, p)                             \

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

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

  76. 

  77. #define sk_ACCESS_DESCRIPTION_pop(sk) \

  78.   ((ACCESS_DESCRIPTION *)sk_pop(      \

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

  80. 

  81. #define sk_ACCESS_DESCRIPTION_dup(sk)      \

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

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

  84. 

  85. #define sk_ACCESS_DESCRIPTION_sort(sk) \

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

  87. 

  88. #define sk_ACCESS_DESCRIPTION_is_sorted(sk) \

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

  90. 

  91. #define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp)                       \

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

  93.    sk_set_cmp_func(                                                        \

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

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

  96.                                             const ACCESS_DESCRIPTION **b), \

  97.                     comp)))

  98. 

  99. 

  100. /* ASN1_ADB_TABLE */

  101. #define sk_ASN1_ADB_TABLE_new(comp)                 \

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

  103.       stack_cmp_func,                               \

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

  105. 

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

  107. 

  108. #define sk_ASN1_ADB_TABLE_num(sk) \

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

  110. 

  111. #define sk_ASN1_ADB_TABLE_zero(sk) \

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

  113. 

  114. #define sk_ASN1_ADB_TABLE_value(sk, i) \

  115.   ((ASN1_ADB_TABLE *)sk_value(         \

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

  117. 

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

  119.   ((ASN1_ADB_TABLE *)sk_set(                                       \

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

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

  122. 

  123. #define sk_ASN1_ADB_TABLE_free(sk) \

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

  125. 

  126. #define sk_ASN1_ADB_TABLE_pop_free(sk, free_func)             \

  127.   sk_pop_free(                                                \

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

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

  130. 

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

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

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

  134. 

  135. #define sk_ASN1_ADB_TABLE_delete(sk, where) \

  136.   ((ASN1_ADB_TABLE *)sk_delete(             \

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

  138. 

  139. #define sk_ASN1_ADB_TABLE_delete_ptr(sk, p)                   \

  140.   ((ASN1_ADB_TABLE *)sk_delete_ptr(                           \

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

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

  143. 

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

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

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

  147. 

  148. #define sk_ASN1_ADB_TABLE_shift(sk) \

  149.   ((ASN1_ADB_TABLE *)sk_shift(      \

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

  151. 

  152. #define sk_ASN1_ADB_TABLE_push(sk, p)                             \

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

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

  155. 

  156. #define sk_ASN1_ADB_TABLE_pop(sk) \

  157.   ((ASN1_ADB_TABLE *)sk_pop(      \

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

  159. 

  160. #define sk_ASN1_ADB_TABLE_dup(sk)      \

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

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

  163. 

  164. #define sk_ASN1_ADB_TABLE_sort(sk) \

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

  166. 

  167. #define sk_ASN1_ADB_TABLE_is_sorted(sk) \

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

  169. 

  170. #define sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp)                       \

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

  172.    sk_set_cmp_func(                                                    \

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

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

  175.                                             const ASN1_ADB_TABLE **b), \

  176.                     comp)))

  177. 

  178. 

  179. /* ASN1_GENERALSTRING */

  180. #define sk_ASN1_GENERALSTRING_new(comp)                                    \

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

  182.       stack_cmp_func,                                                      \

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

  184.       comp)))

  185. 

  186. #define sk_ASN1_GENERALSTRING_new_null() \

  187.   ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())

  188. 

  189. #define sk_ASN1_GENERALSTRING_num(sk) \

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

  191. 

  192. #define sk_ASN1_GENERALSTRING_zero(sk) \

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

  194. 

  195. #define sk_ASN1_GENERALSTRING_value(sk, i) \

  196.   ((ASN1_GENERALSTRING *)sk_value(         \

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

  198. 

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

  200.   ((ASN1_GENERALSTRING *)sk_set(                                       \

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

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

  203. 

  204. #define sk_ASN1_GENERALSTRING_free(sk) \

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

  206. 

  207. #define sk_ASN1_GENERALSTRING_pop_free(sk, free_func)                        \

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

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

  210.                            free_func))

  211. 

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

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

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

  215. 

  216. #define sk_ASN1_GENERALSTRING_delete(sk, where) \

  217.   ((ASN1_GENERALSTRING *)sk_delete(             \

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

  219. 

  220. #define sk_ASN1_GENERALSTRING_delete_ptr(sk, p)                   \

  221.   ((ASN1_GENERALSTRING *)sk_delete_ptr(                           \

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

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

  224. 

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

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

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

  228. 

  229. #define sk_ASN1_GENERALSTRING_shift(sk) \

  230.   ((ASN1_GENERALSTRING *)sk_shift(      \

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

  232. 

  233. #define sk_ASN1_GENERALSTRING_push(sk, p)                             \

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

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

  236. 

  237. #define sk_ASN1_GENERALSTRING_pop(sk) \

  238.   ((ASN1_GENERALSTRING *)sk_pop(      \

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

  240. 

  241. #define sk_ASN1_GENERALSTRING_dup(sk)      \

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

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

  244. 

  245. #define sk_ASN1_GENERALSTRING_sort(sk) \

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

  247. 

  248. #define sk_ASN1_GENERALSTRING_is_sorted(sk) \

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

  250. 

  251. #define sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp)                       \

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

  253.    sk_set_cmp_func(                                                        \

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

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

  256.                                             const ASN1_GENERALSTRING **b), \

  257.                     comp)))

  258. 

  259. 

  260. /* ASN1_INTEGER */

  261. #define sk_ASN1_INTEGER_new(comp)                                              \

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

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

  264.       comp)))

  265. 

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

  267. 

  268. #define sk_ASN1_INTEGER_num(sk) \

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

  270. 

  271. #define sk_ASN1_INTEGER_zero(sk) \

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

  273. 

  274. #define sk_ASN1_INTEGER_value(sk, i) \

  275.   ((ASN1_INTEGER *)sk_value(         \

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

  277. 

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

  279.   ((ASN1_INTEGER *)sk_set(                                       \

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

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

  282. 

  283. #define sk_ASN1_INTEGER_free(sk) \

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

  285. 

  286. #define sk_ASN1_INTEGER_pop_free(sk, free_func)             \

  287.   sk_pop_free(                                              \

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

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

  290. 

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

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

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

  294. 

  295. #define sk_ASN1_INTEGER_delete(sk, where) \

  296.   ((ASN1_INTEGER *)sk_delete(             \

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

  298. 

  299. #define sk_ASN1_INTEGER_delete_ptr(sk, p)                   \

  300.   ((ASN1_INTEGER *)sk_delete_ptr(                           \

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

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

  303. 

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

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

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

  307. 

  308. #define sk_ASN1_INTEGER_shift(sk) \

  309.   ((ASN1_INTEGER *)sk_shift(      \

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

  311. 

  312. #define sk_ASN1_INTEGER_push(sk, p)                             \

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

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

  315. 

  316. #define sk_ASN1_INTEGER_pop(sk) \

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

  318. 

  319. #define sk_ASN1_INTEGER_dup(sk)      \

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

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

  322. 

  323. #define sk_ASN1_INTEGER_sort(sk) \

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

  325. 

  326. #define sk_ASN1_INTEGER_is_sorted(sk) \

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

  328. 

  329. #define sk_ASN1_INTEGER_set_cmp_func(sk, comp)                               \

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

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

  332.       CHECKED_CAST(stack_cmp_func,                                           \

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

  334.                    comp)))

  335. 

  336. 

  337. /* ASN1_OBJECT */

  338. #define sk_ASN1_OBJECT_new(comp)                                             \

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

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

  341.       comp)))

  342. 

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

  344. 

  345. #define sk_ASN1_OBJECT_num(sk) \

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

  347. 

  348. #define sk_ASN1_OBJECT_zero(sk) \

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

  350. 

  351. #define sk_ASN1_OBJECT_value(sk, i) \

  352.   ((ASN1_OBJECT *)sk_value(         \

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

  354. 

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

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

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

  358. 

  359. #define sk_ASN1_OBJECT_free(sk) \

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

  361. 

  362. #define sk_ASN1_OBJECT_pop_free(sk, free_func)             \

  363.   sk_pop_free(                                             \

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

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

  366. 

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

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

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

  370. 

  371. #define sk_ASN1_OBJECT_delete(sk, where) \

  372.   ((ASN1_OBJECT *)sk_delete(             \

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

  374. 

  375. #define sk_ASN1_OBJECT_delete_ptr(sk, p)                   \

  376.   ((ASN1_OBJECT *)sk_delete_ptr(                           \

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

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

  379. 

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

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

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

  383. 

  384. #define sk_ASN1_OBJECT_shift(sk) \

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

  386. 

  387. #define sk_ASN1_OBJECT_push(sk, p)                             \

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

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

  390. 

  391. #define sk_ASN1_OBJECT_pop(sk) \

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

  393. 

  394. #define sk_ASN1_OBJECT_dup(sk)      \

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

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

  397. 

  398. #define sk_ASN1_OBJECT_sort(sk) \

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

  400. 

  401. #define sk_ASN1_OBJECT_is_sorted(sk) \

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

  403. 

  404. #define sk_ASN1_OBJECT_set_cmp_func(sk, comp)                              \

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

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

  407.       CHECKED_CAST(stack_cmp_func,                                         \

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

  409.                    comp)))

  410. 

  411. 

  412. /* ASN1_STRING_TABLE */

  413. #define sk_ASN1_STRING_TABLE_new(comp)                                   \

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

  415.       stack_cmp_func,                                                    \

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

  417.       comp)))

  418. 

  419. #define sk_ASN1_STRING_TABLE_new_null() \

  420.   ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())

  421. 

  422. #define sk_ASN1_STRING_TABLE_num(sk) \

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

  424. 

  425. #define sk_ASN1_STRING_TABLE_zero(sk) \

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

  427. 

  428. #define sk_ASN1_STRING_TABLE_value(sk, i) \

  429.   ((ASN1_STRING_TABLE *)sk_value(         \

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

  431. 

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

  433.   ((ASN1_STRING_TABLE *)sk_set(                                       \

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

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

  436. 

  437. #define sk_ASN1_STRING_TABLE_free(sk) \

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

  439. 

  440. #define sk_ASN1_STRING_TABLE_pop_free(sk, free_func)                        \

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

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

  443.                            free_func))

  444. 

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

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

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

  448. 

  449. #define sk_ASN1_STRING_TABLE_delete(sk, where) \

  450.   ((ASN1_STRING_TABLE *)sk_delete(             \

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

  452. 

  453. #define sk_ASN1_STRING_TABLE_delete_ptr(sk, p)                   \

  454.   ((ASN1_STRING_TABLE *)sk_delete_ptr(                           \

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

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

  457. 

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

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

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

  461. 

  462. #define sk_ASN1_STRING_TABLE_shift(sk) \

  463.   ((ASN1_STRING_TABLE *)sk_shift(      \

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

  465. 

  466. #define sk_ASN1_STRING_TABLE_push(sk, p)                             \

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

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

  469. 

  470. #define sk_ASN1_STRING_TABLE_pop(sk) \

  471.   ((ASN1_STRING_TABLE *)sk_pop(      \

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

  473. 

  474. #define sk_ASN1_STRING_TABLE_dup(sk)      \

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

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

  477. 

  478. #define sk_ASN1_STRING_TABLE_sort(sk) \

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

  480. 

  481. #define sk_ASN1_STRING_TABLE_is_sorted(sk) \

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

  483. 

  484. #define sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp)                       \

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

  486.    sk_set_cmp_func(                                                       \

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

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

  489.                                             const ASN1_STRING_TABLE **b), \

  490.                     comp)))

  491. 

  492. 

  493. /* ASN1_TYPE */

  494. #define sk_ASN1_TYPE_new(comp)     \

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

  496.       CHECKED_CAST(stack_cmp_func, \

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

  498. 

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

  500. 

  501. #define sk_ASN1_TYPE_num(sk) \

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

  503. 

  504. #define sk_ASN1_TYPE_zero(sk) \

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

  506. 

  507. #define sk_ASN1_TYPE_value(sk, i) \

  508.   ((ASN1_TYPE *)sk_value(         \

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

  510. 

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

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

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

  514. 

  515. #define sk_ASN1_TYPE_free(sk) \

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

  517. 

  518. #define sk_ASN1_TYPE_pop_free(sk, free_func)             \

  519.   sk_pop_free(                                           \

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

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

  522. 

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

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

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

  526. 

  527. #define sk_ASN1_TYPE_delete(sk, where)                                       \

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

  529.                           (where)))

  530. 

  531. #define sk_ASN1_TYPE_delete_ptr(sk, p)                   \

  532.   ((ASN1_TYPE *)sk_delete_ptr(                           \

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

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

  535. 

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

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

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

  539. 

  540. #define sk_ASN1_TYPE_shift(sk) \

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

  542. 

  543. #define sk_ASN1_TYPE_push(sk, p)                             \

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

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

  546. 

  547. #define sk_ASN1_TYPE_pop(sk) \

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

  549. 

  550. #define sk_ASN1_TYPE_dup(sk)      \

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

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

  553. 

  554. #define sk_ASN1_TYPE_sort(sk) \

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

  556. 

  557. #define sk_ASN1_TYPE_is_sorted(sk) \

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

  559. 

  560. #define sk_ASN1_TYPE_set_cmp_func(sk, comp)                            \

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

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

  563.       CHECKED_CAST(stack_cmp_func,                                     \

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

  565. 

  566. 

  567. /* ASN1_VALUE */

  568. #define sk_ASN1_VALUE_new(comp)                                            \

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

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

  571.       comp)))

  572. 

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

  574. 

  575. #define sk_ASN1_VALUE_num(sk) \

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

  577. 

  578. #define sk_ASN1_VALUE_zero(sk) \

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

  580. 

  581. #define sk_ASN1_VALUE_value(sk, i) \

  582.   ((ASN1_VALUE *)sk_value(         \

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

  584. 

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

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

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

  588. 

  589. #define sk_ASN1_VALUE_free(sk) \

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

  591. 

  592. #define sk_ASN1_VALUE_pop_free(sk, free_func)             \

  593.   sk_pop_free(                                            \

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

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

  596. 

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

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

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

  600. 

  601. #define sk_ASN1_VALUE_delete(sk, where)                                        \

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

  603.                            (where)))

  604. 

  605. #define sk_ASN1_VALUE_delete_ptr(sk, p)                   \

  606.   ((ASN1_VALUE *)sk_delete_ptr(                           \

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

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

  609. 

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

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

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

  613. 

  614. #define sk_ASN1_VALUE_shift(sk) \

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

  616. 

  617. #define sk_ASN1_VALUE_push(sk, p)                             \

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

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

  620. 

  621. #define sk_ASN1_VALUE_pop(sk) \

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

  623. 

  624. #define sk_ASN1_VALUE_dup(sk)      \

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

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

  627. 

  628. #define sk_ASN1_VALUE_sort(sk) \

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

  630. 

  631. #define sk_ASN1_VALUE_is_sorted(sk) \

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

  633. 

  634. #define sk_ASN1_VALUE_set_cmp_func(sk, comp)                             \

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

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

  637.       CHECKED_CAST(stack_cmp_func,                                       \

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

  639.                    comp)))

  640. 

  641. 

  642. /* BIO */

  643. #define sk_BIO_new(comp)                 \

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

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

  646. 

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

  648. 

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

  650. 

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

  652. 

  653. #define sk_BIO_value(sk, i) \

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

  655. 

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

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

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

  659. 

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

  661. 

  662. #define sk_BIO_pop_free(sk, free_func)                     \

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

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

  665. 

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

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

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

  669. 

  670. #define sk_BIO_delete(sk, where) \

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

  672. 

  673. #define sk_BIO_delete_ptr(sk, p)                                     \

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

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

  676. 

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

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

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

  680. 

  681. #define sk_BIO_shift(sk) \

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

  683. 

  684. #define sk_BIO_push(sk, p)                             \

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

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

  687. 

  688. #define sk_BIO_pop(sk) \

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

  690. 

  691. #define sk_BIO_dup(sk) \

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

  693. 

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

  695. 

  696. #define sk_BIO_is_sorted(sk) \

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

  698. 

  699. #define sk_BIO_set_cmp_func(sk, comp)                                     \

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

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

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

  703.                    comp)))

  704. 

  705. 

  706. /* BY_DIR_ENTRY */

  707. #define sk_BY_DIR_ENTRY_new(comp)                                              \

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

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

  710.       comp)))

  711. 

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

  713. 

  714. #define sk_BY_DIR_ENTRY_num(sk) \

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

  716. 

  717. #define sk_BY_DIR_ENTRY_zero(sk) \

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

  719. 

  720. #define sk_BY_DIR_ENTRY_value(sk, i) \

  721.   ((BY_DIR_ENTRY *)sk_value(         \

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

  723. 

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

  725.   ((BY_DIR_ENTRY *)sk_set(                                       \

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

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

  728. 

  729. #define sk_BY_DIR_ENTRY_free(sk) \

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

  731. 

  732. #define sk_BY_DIR_ENTRY_pop_free(sk, free_func)             \

  733.   sk_pop_free(                                              \

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

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

  736. 

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

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

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

  740. 

  741. #define sk_BY_DIR_ENTRY_delete(sk, where) \

  742.   ((BY_DIR_ENTRY *)sk_delete(             \

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

  744. 

  745. #define sk_BY_DIR_ENTRY_delete_ptr(sk, p)                   \

  746.   ((BY_DIR_ENTRY *)sk_delete_ptr(                           \

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

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

  749. 

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

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

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

  753. 

  754. #define sk_BY_DIR_ENTRY_shift(sk) \

  755.   ((BY_DIR_ENTRY *)sk_shift(      \

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

  757. 

  758. #define sk_BY_DIR_ENTRY_push(sk, p)                             \

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

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

  761. 

  762. #define sk_BY_DIR_ENTRY_pop(sk) \

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

  764. 

  765. #define sk_BY_DIR_ENTRY_dup(sk)      \

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

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

  768. 

  769. #define sk_BY_DIR_ENTRY_sort(sk) \

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

  771. 

  772. #define sk_BY_DIR_ENTRY_is_sorted(sk) \

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

  774. 

  775. #define sk_BY_DIR_ENTRY_set_cmp_func(sk, comp)                               \

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

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

  778.       CHECKED_CAST(stack_cmp_func,                                           \

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

  780.                    comp)))

  781. 

  782. 

  783. /* BY_DIR_HASH */

  784. #define sk_BY_DIR_HASH_new(comp)                                             \

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

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

  787.       comp)))

  788. 

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

  790. 

  791. #define sk_BY_DIR_HASH_num(sk) \

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

  793. 

  794. #define sk_BY_DIR_HASH_zero(sk) \

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

  796. 

  797. #define sk_BY_DIR_HASH_value(sk, i) \

  798.   ((BY_DIR_HASH *)sk_value(         \

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

  800. 

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

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

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

  804. 

  805. #define sk_BY_DIR_HASH_free(sk) \

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

  807. 

  808. #define sk_BY_DIR_HASH_pop_free(sk, free_func)             \

  809.   sk_pop_free(                                             \

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

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

  812. 

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

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

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

  816. 

  817. #define sk_BY_DIR_HASH_delete(sk, where) \

  818.   ((BY_DIR_HASH *)sk_delete(             \

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

  820. 

  821. #define sk_BY_DIR_HASH_delete_ptr(sk, p)                   \

  822.   ((BY_DIR_HASH *)sk_delete_ptr(                           \

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

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

  825. 

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

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

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

  829. 

  830. #define sk_BY_DIR_HASH_shift(sk) \

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

  832. 

  833. #define sk_BY_DIR_HASH_push(sk, p)                             \

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

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

  836. 

  837. #define sk_BY_DIR_HASH_pop(sk) \

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

  839. 

  840. #define sk_BY_DIR_HASH_dup(sk)      \

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

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

  843. 

  844. #define sk_BY_DIR_HASH_sort(sk) \

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

  846. 

  847. #define sk_BY_DIR_HASH_is_sorted(sk) \

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

  849. 

  850. #define sk_BY_DIR_HASH_set_cmp_func(sk, comp)                              \

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

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

  853.       CHECKED_CAST(stack_cmp_func,                                         \

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

  855.                    comp)))

  856. 

  857. 

  858. /* CONF_VALUE */

  859. #define sk_CONF_VALUE_new(comp)                                            \

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

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

  862.       comp)))

  863. 

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

  865. 

  866. #define sk_CONF_VALUE_num(sk) \

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

  868. 

  869. #define sk_CONF_VALUE_zero(sk) \

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

  871. 

  872. #define sk_CONF_VALUE_value(sk, i) \

  873.   ((CONF_VALUE *)sk_value(         \

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

  875. 

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

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

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

  879. 

  880. #define sk_CONF_VALUE_free(sk) \

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

  882. 

  883. #define sk_CONF_VALUE_pop_free(sk, free_func)             \

  884.   sk_pop_free(                                            \

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

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

  887. 

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

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

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

  891. 

  892. #define sk_CONF_VALUE_delete(sk, where)                                        \

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

  894.                            (where)))

  895. 

  896. #define sk_CONF_VALUE_delete_ptr(sk, p)                   \

  897.   ((CONF_VALUE *)sk_delete_ptr(                           \

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

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

  900. 

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

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

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

  904. 

  905. #define sk_CONF_VALUE_shift(sk) \

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

  907. 

  908. #define sk_CONF_VALUE_push(sk, p)                             \

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

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

  911. 

  912. #define sk_CONF_VALUE_pop(sk) \

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

  914. 

  915. #define sk_CONF_VALUE_dup(sk)      \

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

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

  918. 

  919. #define sk_CONF_VALUE_sort(sk) \

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

  921. 

  922. #define sk_CONF_VALUE_is_sorted(sk) \

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

  924. 

  925. #define sk_CONF_VALUE_set_cmp_func(sk, comp)                             \

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

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

  928.       CHECKED_CAST(stack_cmp_func,                                       \

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

  930.                    comp)))

  931. 

  932. 

  933. /* CRYPTO_EX_DATA_FUNCS */

  934. #define sk_CRYPTO_EX_DATA_FUNCS_new(comp)                                      \

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

  936.       stack_cmp_func,                                                          \

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

  938.       comp)))

  939. 

  940. #define sk_CRYPTO_EX_DATA_FUNCS_new_null() \

  941.   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())

  942. 

  943. #define sk_CRYPTO_EX_DATA_FUNCS_num(sk) \

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

  945. 

  946. #define sk_CRYPTO_EX_DATA_FUNCS_zero(sk) \

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

  948. 

  949. #define sk_CRYPTO_EX_DATA_FUNCS_value(sk, i)                              \

  950.   ((CRYPTO_EX_DATA_FUNCS *)sk_value(                                      \

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

  952.       (i)))

  953. 

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

  955.   ((CRYPTO_EX_DATA_FUNCS *)sk_set(                                       \

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

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

  958. 

  959. #define sk_CRYPTO_EX_DATA_FUNCS_free(sk) \

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

  961. 

  962. #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func)                        \

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

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

  965.                            free_func))

  966. 

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

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

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

  970. 

  971. #define sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where) \

  972.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete(             \

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

  974. 

  975. #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p)                   \

  976.   ((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr(                           \

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

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

  979. 

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

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

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

  983. 

  984. #define sk_CRYPTO_EX_DATA_FUNCS_shift(sk) \

  985.   ((CRYPTO_EX_DATA_FUNCS *)sk_shift(      \

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

  987. 

  988. #define sk_CRYPTO_EX_DATA_FUNCS_push(sk, p)                             \

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

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

  991. 

  992. #define sk_CRYPTO_EX_DATA_FUNCS_pop(sk) \

  993.   ((CRYPTO_EX_DATA_FUNCS *)sk_pop(      \

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

  995. 

  996. #define sk_CRYPTO_EX_DATA_FUNCS_dup(sk)      \

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

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

  999. 

  1000. #define sk_CRYPTO_EX_DATA_FUNCS_sort(sk) \

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

  1002. 

  1003. #define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk) \

  1004.   sk_is_sorted(                               \

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

  1006. 

  1007. #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp)                       \

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

  1009.    sk_set_cmp_func(                                                          \

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

  1011.        CHECKED_CAST(stack_cmp_func, int (*)(const CRYPTO_EX_DATA_FUNCS **a,  \

  1012.                                             const CRYPTO_EX_DATA_FUNCS **b), \

  1013.                     comp)))

  1014. 

  1015. 

  1016. /* DIST_POINT */

  1017. #define sk_DIST_POINT_new(comp)                                            \

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

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

  1020.       comp)))

  1021. 

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

  1023. 

  1024. #define sk_DIST_POINT_num(sk) \

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

  1026. 

  1027. #define sk_DIST_POINT_zero(sk) \

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

  1029. 

  1030. #define sk_DIST_POINT_value(sk, i) \

  1031.   ((DIST_POINT *)sk_value(         \

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

  1033. 

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

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

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

  1037. 

  1038. #define sk_DIST_POINT_free(sk) \

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

  1040. 

  1041. #define sk_DIST_POINT_pop_free(sk, free_func)             \

  1042.   sk_pop_free(                                            \

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

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

  1045. 

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

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

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

  1049. 

  1050. #define sk_DIST_POINT_delete(sk, where)                                        \

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

  1052.                            (where)))

  1053. 

  1054. #define sk_DIST_POINT_delete_ptr(sk, p)                   \

  1055.   ((DIST_POINT *)sk_delete_ptr(                           \

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

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

  1058. 

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

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

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

  1062. 

  1063. #define sk_DIST_POINT_shift(sk) \

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

  1065. 

  1066. #define sk_DIST_POINT_push(sk, p)                             \

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

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

  1069. 

  1070. #define sk_DIST_POINT_pop(sk) \

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

  1072. 

  1073. #define sk_DIST_POINT_dup(sk)      \

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

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

  1076. 

  1077. #define sk_DIST_POINT_sort(sk) \

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

  1079. 

  1080. #define sk_DIST_POINT_is_sorted(sk) \

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

  1082. 

  1083. #define sk_DIST_POINT_set_cmp_func(sk, comp)                             \

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

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

  1086.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1088.                    comp)))

  1089. 

  1090. 

  1091. /* GENERAL_NAME */

  1092. #define sk_GENERAL_NAME_new(comp)                                              \

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

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

  1095.       comp)))

  1096. 

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

  1098. 

  1099. #define sk_GENERAL_NAME_num(sk) \

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

  1101. 

  1102. #define sk_GENERAL_NAME_zero(sk) \

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

  1104. 

  1105. #define sk_GENERAL_NAME_value(sk, i) \

  1106.   ((GENERAL_NAME *)sk_value(         \

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

  1108. 

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

  1110.   ((GENERAL_NAME *)sk_set(                                       \

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

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

  1113. 

  1114. #define sk_GENERAL_NAME_free(sk) \

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

  1116. 

  1117. #define sk_GENERAL_NAME_pop_free(sk, free_func)             \

  1118.   sk_pop_free(                                              \

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

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

  1121. 

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

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

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

  1125. 

  1126. #define sk_GENERAL_NAME_delete(sk, where) \

  1127.   ((GENERAL_NAME *)sk_delete(             \

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

  1129. 

  1130. #define sk_GENERAL_NAME_delete_ptr(sk, p)                   \

  1131.   ((GENERAL_NAME *)sk_delete_ptr(                           \

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

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

  1134. 

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

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

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

  1138. 

  1139. #define sk_GENERAL_NAME_shift(sk) \

  1140.   ((GENERAL_NAME *)sk_shift(      \

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

  1142. 

  1143. #define sk_GENERAL_NAME_push(sk, p)                             \

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

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

  1146. 

  1147. #define sk_GENERAL_NAME_pop(sk) \

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

  1149. 

  1150. #define sk_GENERAL_NAME_dup(sk)      \

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

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

  1153. 

  1154. #define sk_GENERAL_NAME_sort(sk) \

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

  1156. 

  1157. #define sk_GENERAL_NAME_is_sorted(sk) \

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

  1159. 

  1160. #define sk_GENERAL_NAME_set_cmp_func(sk, comp)                               \

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

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

  1163.       CHECKED_CAST(stack_cmp_func,                                           \

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

  1165.                    comp)))

  1166. 

  1167. 

  1168. /* GENERAL_NAMES */

  1169. #define sk_GENERAL_NAMES_new(comp)                 \

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

  1171.       stack_cmp_func,                              \

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

  1173. 

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

  1175. 

  1176. #define sk_GENERAL_NAMES_num(sk) \

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

  1178. 

  1179. #define sk_GENERAL_NAMES_zero(sk) \

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

  1181. 

  1182. #define sk_GENERAL_NAMES_value(sk, i) \

  1183.   ((GENERAL_NAMES *)sk_value(         \

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

  1185. 

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

  1187.   ((GENERAL_NAMES *)sk_set(                                       \

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

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

  1190. 

  1191. #define sk_GENERAL_NAMES_free(sk) \

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

  1193. 

  1194. #define sk_GENERAL_NAMES_pop_free(sk, free_func)             \

  1195.   sk_pop_free(                                               \

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

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

  1198. 

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

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

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

  1202. 

  1203. #define sk_GENERAL_NAMES_delete(sk, where) \

  1204.   ((GENERAL_NAMES *)sk_delete(             \

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

  1206. 

  1207. #define sk_GENERAL_NAMES_delete_ptr(sk, p)                   \

  1208.   ((GENERAL_NAMES *)sk_delete_ptr(                           \

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

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

  1211. 

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

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

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

  1215. 

  1216. #define sk_GENERAL_NAMES_shift(sk) \

  1217.   ((GENERAL_NAMES *)sk_shift(      \

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

  1219. 

  1220. #define sk_GENERAL_NAMES_push(sk, p)                             \

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

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

  1223. 

  1224. #define sk_GENERAL_NAMES_pop(sk) \

  1225.   ((GENERAL_NAMES *)sk_pop(      \

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

  1227. 

  1228. #define sk_GENERAL_NAMES_dup(sk)      \

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

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

  1231. 

  1232. #define sk_GENERAL_NAMES_sort(sk) \

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

  1234. 

  1235. #define sk_GENERAL_NAMES_is_sorted(sk) \

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

  1237. 

  1238. #define sk_GENERAL_NAMES_set_cmp_func(sk, comp)                                \

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

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

  1241.       CHECKED_CAST(stack_cmp_func,                                             \

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

  1243.                    comp)))

  1244. 

  1245. 

  1246. /* GENERAL_SUBTREE */

  1247. #define sk_GENERAL_SUBTREE_new(comp)                 \

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

  1249.       stack_cmp_func,                                \

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

  1251. 

  1252. #define sk_GENERAL_SUBTREE_new_null() \

  1253.   ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())

  1254. 

  1255. #define sk_GENERAL_SUBTREE_num(sk) \

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

  1257. 

  1258. #define sk_GENERAL_SUBTREE_zero(sk) \

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

  1260. 

  1261. #define sk_GENERAL_SUBTREE_value(sk, i) \

  1262.   ((GENERAL_SUBTREE *)sk_value(         \

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

  1264. 

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

  1266.   ((GENERAL_SUBTREE *)sk_set(                                       \

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

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

  1269. 

  1270. #define sk_GENERAL_SUBTREE_free(sk) \

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

  1272. 

  1273. #define sk_GENERAL_SUBTREE_pop_free(sk, free_func)             \

  1274.   sk_pop_free(                                                 \

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

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

  1277. 

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

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

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

  1281. 

  1282. #define sk_GENERAL_SUBTREE_delete(sk, where) \

  1283.   ((GENERAL_SUBTREE *)sk_delete(             \

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

  1285. 

  1286. #define sk_GENERAL_SUBTREE_delete_ptr(sk, p)                   \

  1287.   ((GENERAL_SUBTREE *)sk_delete_ptr(                           \

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

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

  1290. 

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

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

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

  1294. 

  1295. #define sk_GENERAL_SUBTREE_shift(sk) \

  1296.   ((GENERAL_SUBTREE *)sk_shift(      \

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

  1298. 

  1299. #define sk_GENERAL_SUBTREE_push(sk, p)                             \

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

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

  1302. 

  1303. #define sk_GENERAL_SUBTREE_pop(sk) \

  1304.   ((GENERAL_SUBTREE *)sk_pop(      \

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

  1306. 

  1307. #define sk_GENERAL_SUBTREE_dup(sk)      \

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

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

  1310. 

  1311. #define sk_GENERAL_SUBTREE_sort(sk) \

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

  1313. 

  1314. #define sk_GENERAL_SUBTREE_is_sorted(sk) \

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

  1316. 

  1317. #define sk_GENERAL_SUBTREE_set_cmp_func(sk, comp)                       \

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

  1319.    sk_set_cmp_func(                                                     \

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

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

  1322.                                             const GENERAL_SUBTREE **b), \

  1323.                     comp)))

  1324. 

  1325. 

  1326. /* MIME_HEADER */

  1327. #define sk_MIME_HEADER_new(comp)                                             \

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

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

  1330.       comp)))

  1331. 

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

  1333. 

  1334. #define sk_MIME_HEADER_num(sk) \

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

  1336. 

  1337. #define sk_MIME_HEADER_zero(sk) \

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

  1339. 

  1340. #define sk_MIME_HEADER_value(sk, i) \

  1341.   ((MIME_HEADER *)sk_value(         \

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

  1343. 

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

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

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

  1347. 

  1348. #define sk_MIME_HEADER_free(sk) \

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

  1350. 

  1351. #define sk_MIME_HEADER_pop_free(sk, free_func)             \

  1352.   sk_pop_free(                                             \

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

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

  1355. 

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

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

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

  1359. 

  1360. #define sk_MIME_HEADER_delete(sk, where) \

  1361.   ((MIME_HEADER *)sk_delete(             \

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

  1363. 

  1364. #define sk_MIME_HEADER_delete_ptr(sk, p)                   \

  1365.   ((MIME_HEADER *)sk_delete_ptr(                           \

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

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

  1368. 

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

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

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

  1372. 

  1373. #define sk_MIME_HEADER_shift(sk) \

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

  1375. 

  1376. #define sk_MIME_HEADER_push(sk, p)                             \

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

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

  1379. 

  1380. #define sk_MIME_HEADER_pop(sk) \

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

  1382. 

  1383. #define sk_MIME_HEADER_dup(sk)      \

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

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

  1386. 

  1387. #define sk_MIME_HEADER_sort(sk) \

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

  1389. 

  1390. #define sk_MIME_HEADER_is_sorted(sk) \

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

  1392. 

  1393. #define sk_MIME_HEADER_set_cmp_func(sk, comp)                              \

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

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

  1396.       CHECKED_CAST(stack_cmp_func,                                         \

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

  1398.                    comp)))

  1399. 

  1400. 

  1401. /* PKCS7_SIGNER_INFO */

  1402. #define sk_PKCS7_SIGNER_INFO_new(comp)                                   \

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

  1404.       stack_cmp_func,                                                    \

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

  1406.       comp)))

  1407. 

  1408. #define sk_PKCS7_SIGNER_INFO_new_null() \

  1409.   ((STACK_OF(PKCS7_SIGNER_INFO) *)sk_new_null())

  1410. 

  1411. #define sk_PKCS7_SIGNER_INFO_num(sk) \

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

  1413. 

  1414. #define sk_PKCS7_SIGNER_INFO_zero(sk) \

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

  1416. 

  1417. #define sk_PKCS7_SIGNER_INFO_value(sk, i) \

  1418.   ((PKCS7_SIGNER_INFO *)sk_value(         \

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

  1420. 

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

  1422.   ((PKCS7_SIGNER_INFO *)sk_set(                                       \

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

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

  1425. 

  1426. #define sk_PKCS7_SIGNER_INFO_free(sk) \

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

  1428. 

  1429. #define sk_PKCS7_SIGNER_INFO_pop_free(sk, free_func)                        \

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

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

  1432.                            free_func))

  1433. 

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

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

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

  1437. 

  1438. #define sk_PKCS7_SIGNER_INFO_delete(sk, where) \

  1439.   ((PKCS7_SIGNER_INFO *)sk_delete(             \

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

  1441. 

  1442. #define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, p)                   \

  1443.   ((PKCS7_SIGNER_INFO *)sk_delete_ptr(                           \

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

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

  1446. 

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

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

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

  1450. 

  1451. #define sk_PKCS7_SIGNER_INFO_shift(sk) \

  1452.   ((PKCS7_SIGNER_INFO *)sk_shift(      \

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

  1454. 

  1455. #define sk_PKCS7_SIGNER_INFO_push(sk, p)                             \

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

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

  1458. 

  1459. #define sk_PKCS7_SIGNER_INFO_pop(sk) \

  1460.   ((PKCS7_SIGNER_INFO *)sk_pop(      \

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

  1462. 

  1463. #define sk_PKCS7_SIGNER_INFO_dup(sk)      \

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

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

  1466. 

  1467. #define sk_PKCS7_SIGNER_INFO_sort(sk) \

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

  1469. 

  1470. #define sk_PKCS7_SIGNER_INFO_is_sorted(sk) \

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

  1472. 

  1473. #define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, comp)                       \

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

  1475.    sk_set_cmp_func(                                                       \

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

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

  1478.                                             const PKCS7_SIGNER_INFO **b), \

  1479.                     comp)))

  1480. 

  1481. 

  1482. /* PKCS7_RECIP_INFO */

  1483. #define sk_PKCS7_RECIP_INFO_new(comp)                 \

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

  1485.       stack_cmp_func,                                 \

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

  1487. 

  1488. #define sk_PKCS7_RECIP_INFO_new_null() \

  1489.   ((STACK_OF(PKCS7_RECIP_INFO) *)sk_new_null())

  1490. 

  1491. #define sk_PKCS7_RECIP_INFO_num(sk) \

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

  1493. 

  1494. #define sk_PKCS7_RECIP_INFO_zero(sk) \

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

  1496. 

  1497. #define sk_PKCS7_RECIP_INFO_value(sk, i) \

  1498.   ((PKCS7_RECIP_INFO *)sk_value(         \

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

  1500. 

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

  1502.   ((PKCS7_RECIP_INFO *)sk_set(                                       \

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

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

  1505. 

  1506. #define sk_PKCS7_RECIP_INFO_free(sk) \

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

  1508. 

  1509. #define sk_PKCS7_RECIP_INFO_pop_free(sk, free_func)             \

  1510.   sk_pop_free(                                                  \

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

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

  1513. 

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

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

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

  1517. 

  1518. #define sk_PKCS7_RECIP_INFO_delete(sk, where) \

  1519.   ((PKCS7_RECIP_INFO *)sk_delete(             \

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

  1521. 

  1522. #define sk_PKCS7_RECIP_INFO_delete_ptr(sk, p)                   \

  1523.   ((PKCS7_RECIP_INFO *)sk_delete_ptr(                           \

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

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

  1526. 

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

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

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

  1530. 

  1531. #define sk_PKCS7_RECIP_INFO_shift(sk) \

  1532.   ((PKCS7_RECIP_INFO *)sk_shift(      \

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

  1534. 

  1535. #define sk_PKCS7_RECIP_INFO_push(sk, p)                             \

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

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

  1538. 

  1539. #define sk_PKCS7_RECIP_INFO_pop(sk) \

  1540.   ((PKCS7_RECIP_INFO *)sk_pop(      \

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

  1542. 

  1543. #define sk_PKCS7_RECIP_INFO_dup(sk)      \

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

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

  1546. 

  1547. #define sk_PKCS7_RECIP_INFO_sort(sk) \

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

  1549. 

  1550. #define sk_PKCS7_RECIP_INFO_is_sorted(sk) \

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

  1552. 

  1553. #define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, comp)                       \

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

  1555.    sk_set_cmp_func(                                                      \

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

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

  1558.                                             const PKCS7_RECIP_INFO **b), \

  1559.                     comp)))

  1560. 

  1561. 

  1562. /* POLICYINFO */

  1563. #define sk_POLICYINFO_new(comp)                                            \

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

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

  1566.       comp)))

  1567. 

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

  1569. 

  1570. #define sk_POLICYINFO_num(sk) \

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

  1572. 

  1573. #define sk_POLICYINFO_zero(sk) \

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

  1575. 

  1576. #define sk_POLICYINFO_value(sk, i) \

  1577.   ((POLICYINFO *)sk_value(         \

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

  1579. 

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

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

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

  1583. 

  1584. #define sk_POLICYINFO_free(sk) \

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

  1586. 

  1587. #define sk_POLICYINFO_pop_free(sk, free_func)             \

  1588.   sk_pop_free(                                            \

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

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

  1591. 

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

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

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

  1595. 

  1596. #define sk_POLICYINFO_delete(sk, where)                                        \

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

  1598.                            (where)))

  1599. 

  1600. #define sk_POLICYINFO_delete_ptr(sk, p)                   \

  1601.   ((POLICYINFO *)sk_delete_ptr(                           \

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

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

  1604. 

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

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

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

  1608. 

  1609. #define sk_POLICYINFO_shift(sk) \

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

  1611. 

  1612. #define sk_POLICYINFO_push(sk, p)                             \

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

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

  1615. 

  1616. #define sk_POLICYINFO_pop(sk) \

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

  1618. 

  1619. #define sk_POLICYINFO_dup(sk)      \

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

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

  1622. 

  1623. #define sk_POLICYINFO_sort(sk) \

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

  1625. 

  1626. #define sk_POLICYINFO_is_sorted(sk) \

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

  1628. 

  1629. #define sk_POLICYINFO_set_cmp_func(sk, comp)                             \

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

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

  1632.       CHECKED_CAST(stack_cmp_func,                                       \

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

  1634.                    comp)))

  1635. 

  1636. 

  1637. /* POLICYQUALINFO */

  1638. #define sk_POLICYQUALINFO_new(comp)                 \

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

  1640.       stack_cmp_func,                               \

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

  1642. 

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

  1644. 

  1645. #define sk_POLICYQUALINFO_num(sk) \

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

  1647. 

  1648. #define sk_POLICYQUALINFO_zero(sk) \

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

  1650. 

  1651. #define sk_POLICYQUALINFO_value(sk, i) \

  1652.   ((POLICYQUALINFO *)sk_value(         \

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

  1654. 

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

  1656.   ((POLICYQUALINFO *)sk_set(                                       \

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

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

  1659. 

  1660. #define sk_POLICYQUALINFO_free(sk) \

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

  1662. 

  1663. #define sk_POLICYQUALINFO_pop_free(sk, free_func)             \

  1664.   sk_pop_free(                                                \

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

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

  1667. 

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

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

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

  1671. 

  1672. #define sk_POLICYQUALINFO_delete(sk, where) \

  1673.   ((POLICYQUALINFO *)sk_delete(             \

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

  1675. 

  1676. #define sk_POLICYQUALINFO_delete_ptr(sk, p)                   \

  1677.   ((POLICYQUALINFO *)sk_delete_ptr(                           \

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

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

  1680. 

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

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

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

  1684. 

  1685. #define sk_POLICYQUALINFO_shift(sk) \

  1686.   ((POLICYQUALINFO *)sk_shift(      \

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

  1688. 

  1689. #define sk_POLICYQUALINFO_push(sk, p)                             \

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

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

  1692. 

  1693. #define sk_POLICYQUALINFO_pop(sk) \

  1694.   ((POLICYQUALINFO *)sk_pop(      \

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

  1696. 

  1697. #define sk_POLICYQUALINFO_dup(sk)      \

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

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

  1700. 

  1701. #define sk_POLICYQUALINFO_sort(sk) \

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

  1703. 

  1704. #define sk_POLICYQUALINFO_is_sorted(sk) \

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

  1706. 

  1707. #define sk_POLICYQUALINFO_set_cmp_func(sk, comp)                       \

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

  1709.    sk_set_cmp_func(                                                    \

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

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

  1712.                                             const POLICYQUALINFO **b), \

  1713.                     comp)))

  1714. 

  1715. 

  1716. /* POLICY_MAPPING */

  1717. #define sk_POLICY_MAPPING_new(comp)                 \

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

  1719.       stack_cmp_func,                               \

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

  1721. 

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

  1723. 

  1724. #define sk_POLICY_MAPPING_num(sk) \

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

  1726. 

  1727. #define sk_POLICY_MAPPING_zero(sk) \

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

  1729. 

  1730. #define sk_POLICY_MAPPING_value(sk, i) \

  1731.   ((POLICY_MAPPING *)sk_value(         \

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

  1733. 

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

  1735.   ((POLICY_MAPPING *)sk_set(                                       \

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

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

  1738. 

  1739. #define sk_POLICY_MAPPING_free(sk) \

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

  1741. 

  1742. #define sk_POLICY_MAPPING_pop_free(sk, free_func)             \

  1743.   sk_pop_free(                                                \

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

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

  1746. 

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

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

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

  1750. 

  1751. #define sk_POLICY_MAPPING_delete(sk, where) \

  1752.   ((POLICY_MAPPING *)sk_delete(             \

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

  1754. 

  1755. #define sk_POLICY_MAPPING_delete_ptr(sk, p)                   \

  1756.   ((POLICY_MAPPING *)sk_delete_ptr(                           \

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

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

  1759. 

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

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

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

  1763. 

  1764. #define sk_POLICY_MAPPING_shift(sk) \

  1765.   ((POLICY_MAPPING *)sk_shift(      \

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

  1767. 

  1768. #define sk_POLICY_MAPPING_push(sk, p)                             \

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

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

  1771. 

  1772. #define sk_POLICY_MAPPING_pop(sk) \

  1773.   ((POLICY_MAPPING *)sk_pop(      \

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

  1775. 

  1776. #define sk_POLICY_MAPPING_dup(sk)      \

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

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

  1779. 

  1780. #define sk_POLICY_MAPPING_sort(sk) \

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

  1782. 

  1783. #define sk_POLICY_MAPPING_is_sorted(sk) \

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

  1785. 

  1786. #define sk_POLICY_MAPPING_set_cmp_func(sk, comp)                       \

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

  1788.    sk_set_cmp_func(                                                    \

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

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

  1791.                                             const POLICY_MAPPING **b), \

  1792.                     comp)))

  1793. 

  1794. 

  1795. /* SSL_COMP */

  1796. #define sk_SSL_COMP_new(comp)                 \

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

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

  1799. 

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

  1801. 

  1802. #define sk_SSL_COMP_num(sk) \

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

  1804. 

  1805. #define sk_SSL_COMP_zero(sk) \

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

  1807. 

  1808. #define sk_SSL_COMP_value(sk, i) \

  1809.   ((SSL_COMP *)sk_value(         \

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

  1811. 

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

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

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

  1815. 

  1816. #define sk_SSL_COMP_free(sk) \

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

  1818. 

  1819. #define sk_SSL_COMP_pop_free(sk, free_func)                     \

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

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

  1822. 

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

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

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

  1826. 

  1827. #define sk_SSL_COMP_delete(sk, where)                                      \

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

  1829.                          (where)))

  1830. 

  1831. #define sk_SSL_COMP_delete_ptr(sk, p)                                          \

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

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

  1834. 

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

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

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

  1838. 

  1839. #define sk_SSL_COMP_shift(sk) \

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

  1841. 

  1842. #define sk_SSL_COMP_push(sk, p)                             \

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

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

  1845. 

  1846. #define sk_SSL_COMP_pop(sk) \

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

  1848. 

  1849. #define sk_SSL_COMP_dup(sk)      \

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

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

  1852. 

  1853. #define sk_SSL_COMP_sort(sk) \

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

  1855. 

  1856. #define sk_SSL_COMP_is_sorted(sk) \

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

  1858. 

  1859. #define sk_SSL_COMP_set_cmp_func(sk, comp)                           \

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

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

  1862.       CHECKED_CAST(stack_cmp_func,                                   \

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

  1864. 

  1865. 

  1866. /* STACK_OF_X509_NAME_ENTRY */

  1867. #define sk_STACK_OF_X509_NAME_ENTRY_new(comp)                      \

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

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

  1870.                               const STACK_OF_X509_NAME_ENTRY **b), \

  1871.       comp)))

  1872. 

  1873. #define sk_STACK_OF_X509_NAME_ENTRY_new_null() \

  1874.   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())

  1875. 

  1876. #define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \

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

  1878. 

  1879. #define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \

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

  1881. 

  1882. #define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i)                              \

  1883.   ((STACK_OF_X509_NAME_ENTRY *)sk_value(                                      \

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

  1885.       (i)))

  1886. 

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

  1888.   ((STACK_OF_X509_NAME_ENTRY *)sk_set(                                       \

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

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

  1891. 

  1892. #define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \

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

  1894. 

  1895. #define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func)                \

  1896.   sk_pop_free(                                                             \

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

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

  1899.                    free_func))

  1900. 

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

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

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

  1904. 

  1905. #define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where)                   \

  1906.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete(                               \

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

  1908.       (where)))

  1909. 

  1910. #define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  1911.   ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr(                           \

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

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

  1914. 

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

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

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

  1918. 

  1919. #define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \

  1920.   ((STACK_OF_X509_NAME_ENTRY *)sk_shift(      \

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

  1922. 

  1923. #define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p)                             \

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

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

  1926. 

  1927. #define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \

  1928.   ((STACK_OF_X509_NAME_ENTRY *)sk_pop(      \

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

  1930. 

  1931. #define sk_STACK_OF_X509_NAME_ENTRY_dup(sk)      \

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

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

  1934. 

  1935. #define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \

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

  1937. 

  1938. #define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \

  1939.   sk_is_sorted(                                   \

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

  1941. 

  1942. #define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp)               \

  1943.   ((int (*)(const STACK_OF_X509_NAME_ENTRY **a,                          \

  1944.             const STACK_OF_X509_NAME_ENTRY **b))                         \

  1945.    sk_set_cmp_func(                                                      \

  1946.        CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \

  1947.        CHECKED_CAST(stack_cmp_func,                                      \

  1948.                     int (*)(const STACK_OF_X509_NAME_ENTRY **a,          \

  1949.                             const STACK_OF_X509_NAME_ENTRY **b),         \

  1950.                     comp)))

  1951. 

  1952. 

  1953. /* SXNETID */

  1954. #define sk_SXNETID_new(comp)                 \

  1955.   ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \

  1956.       stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))

  1957. 

  1958. #define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null())

  1959. 

  1960. #define sk_SXNETID_num(sk) \

  1961.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  1962. 

  1963. #define sk_SXNETID_zero(sk) \

  1964.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));

  1965. 

  1966. #define sk_SXNETID_value(sk, i)                                               \

  1967.   ((SXNETID *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk), \

  1968.                        (i)))

  1969. 

  1970. #define sk_SXNETID_set(sk, i, p)                                           \

  1971.   ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \

  1972.                      CHECKED_CAST(void *, SXNETID *, p)))

  1973. 

  1974. #define sk_SXNETID_free(sk) \

  1975.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  1976. 

  1977. #define sk_SXNETID_pop_free(sk, free_func)                     \

  1978.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  1979.               CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))

  1980. 

  1981. #define sk_SXNETID_insert(sk, p, where)                      \

  1982.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  1983.             CHECKED_CAST(void *, SXNETID *, p), (where))

  1984. 

  1985. #define sk_SXNETID_delete(sk, where)                                     \

  1986.   ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  1987.                         (where)))

  1988. 

  1989. #define sk_SXNETID_delete_ptr(sk, p)                                         \

  1990.   ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  1991.                             CHECKED_CAST(void *, SXNETID *, p)))

  1992. 

  1993. #define sk_SXNETID_find(sk, out_index, p)                               \

  1994.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \

  1995.           CHECKED_CAST(void *, SXNETID *, p))

  1996. 

  1997. #define sk_SXNETID_shift(sk) \

  1998.   ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  1999. 

  2000. #define sk_SXNETID_push(sk, p)                             \

  2001.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \

  2002.           CHECKED_CAST(void *, SXNETID *, p))

  2003. 

  2004. #define sk_SXNETID_pop(sk) \

  2005.   ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))

  2006. 

  2007. #define sk_SXNETID_dup(sk)      \

  2008.   ((STACK_OF(SXNETID) *)sk_dup( \

  2009.       CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk)))

  2010. 

  2011. #define sk_SXNETID_sort(sk) \

  2012.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))

  2013. 

  2014. #define sk_SXNETID_is_sorted(sk) \

  2015.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SXNETID) *, sk))

  2016. 

  2017. #define sk_SXNETID_set_cmp_func(sk, comp)                          \

  2018.   ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \

  2019.       CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk),             \

  2020.       CHECKED_CAST(stack_cmp_func,                                 \

  2021.                    int (*)(const SXNETID **a, const SXNETID **b), comp)))

  2022. 

  2023. 

  2024. /* X509 */

  2025. #define sk_X509_new(comp)                 \

  2026.   ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \

  2027.       stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))

  2028. 

  2029. #define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null())

  2030. 

  2031. #define sk_X509_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2032. 

  2033. #define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));

  2034. 

  2035. #define sk_X509_value(sk, i) \

  2036.   ((X509 *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk), (i)))

  2037. 

  2038. #define sk_X509_set(sk, i, p)                                        \

  2039.   ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \

  2040.                   CHECKED_CAST(void *, X509 *, p)))

  2041. 

  2042. #define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2043. 

  2044. #define sk_X509_pop_free(sk, free_func)                     \

  2045.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2046.               CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))

  2047. 

  2048. #define sk_X509_insert(sk, p, where)                      \

  2049.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2050.             CHECKED_CAST(void *, X509 *, p), (where))

  2051. 

  2052. #define sk_X509_delete(sk, where) \

  2053.   ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))

  2054. 

  2055. #define sk_X509_delete_ptr(sk, p)                                      \

  2056.   ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2057.                          CHECKED_CAST(void *, X509 *, p)))

  2058. 

  2059. #define sk_X509_find(sk, out_index, p)                               \

  2060.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \

  2061.           CHECKED_CAST(void *, X509 *, p))

  2062. 

  2063. #define sk_X509_shift(sk) \

  2064.   ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2065. 

  2066. #define sk_X509_push(sk, p)                             \

  2067.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \

  2068.           CHECKED_CAST(void *, X509 *, p))

  2069. 

  2070. #define sk_X509_pop(sk) \

  2071.   ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))

  2072. 

  2073. #define sk_X509_dup(sk) \

  2074.   ((STACK_OF(X509) *)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk)))

  2075. 

  2076. #define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

  2077. 

  2078. #define sk_X509_is_sorted(sk) \

  2079.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509) *, sk))

  2080. 

  2081. #define sk_X509_set_cmp_func(sk, comp)                                      \

  2082.   ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func(                \

  2083.       CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk),                         \

  2084.       CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \

  2085.                    comp)))

  2086. 

  2087. 

  2088. /* X509V3_EXT_METHOD */

  2089. #define sk_X509V3_EXT_METHOD_new(comp)                                   \

  2090.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST(                   \

  2091.       stack_cmp_func,                                                    \

  2092.       int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \

  2093.       comp)))

  2094. 

  2095. #define sk_X509V3_EXT_METHOD_new_null() \

  2096.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())

  2097. 

  2098. #define sk_X509V3_EXT_METHOD_num(sk) \

  2099.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2100. 

  2101. #define sk_X509V3_EXT_METHOD_zero(sk) \

  2102.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));

  2103. 

  2104. #define sk_X509V3_EXT_METHOD_value(sk, i) \

  2105.   ((X509V3_EXT_METHOD *)sk_value(         \

  2106.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), (i)))

  2107. 

  2108. #define sk_X509V3_EXT_METHOD_set(sk, i, p)                            \

  2109.   ((X509V3_EXT_METHOD *)sk_set(                                       \

  2110.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \

  2111.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2112. 

  2113. #define sk_X509V3_EXT_METHOD_free(sk) \

  2114.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2115. 

  2116. #define sk_X509V3_EXT_METHOD_pop_free(sk, free_func)                        \

  2117.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),    \

  2118.               CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \

  2119.                            free_func))

  2120. 

  2121. #define sk_X509V3_EXT_METHOD_insert(sk, p, where)                      \

  2122.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2123.             CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))

  2124. 

  2125. #define sk_X509V3_EXT_METHOD_delete(sk, where) \

  2126.   ((X509V3_EXT_METHOD *)sk_delete(             \

  2127.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))

  2128. 

  2129. #define sk_X509V3_EXT_METHOD_delete_ptr(sk, p)                   \

  2130.   ((X509V3_EXT_METHOD *)sk_delete_ptr(                           \

  2131.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2132.       CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

  2133. 

  2134. #define sk_X509V3_EXT_METHOD_find(sk, out_index, p)                  \

  2135.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2136.           (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2137. 

  2138. #define sk_X509V3_EXT_METHOD_shift(sk) \

  2139.   ((X509V3_EXT_METHOD *)sk_shift(      \

  2140.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2141. 

  2142. #define sk_X509V3_EXT_METHOD_push(sk, p)                             \

  2143.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \

  2144.           CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

  2145. 

  2146. #define sk_X509V3_EXT_METHOD_pop(sk) \

  2147.   ((X509V3_EXT_METHOD *)sk_pop(      \

  2148.       CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2149. 

  2150. #define sk_X509V3_EXT_METHOD_dup(sk)      \

  2151.   ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \

  2152.       CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))

  2153. 

  2154. #define sk_X509V3_EXT_METHOD_sort(sk) \

  2155.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))

  2156. 

  2157. #define sk_X509V3_EXT_METHOD_is_sorted(sk) \

  2158.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

  2159. 

  2160. #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp)                       \

  2161.   ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b))    \

  2162.    sk_set_cmp_func(                                                       \

  2163.        CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),         \

  2164.        CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a,  \

  2165.                                             const X509V3_EXT_METHOD **b), \

  2166.                     comp)))

  2167. 

  2168. 

  2169. /* X509_ALGOR */

  2170. #define sk_X509_ALGOR_new(comp)                                            \

  2171.   ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST(                            \

  2172.       stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \

  2173.       comp)))

  2174. 

  2175. #define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null())

  2176. 

  2177. #define sk_X509_ALGOR_num(sk) \

  2178.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2179. 

  2180. #define sk_X509_ALGOR_zero(sk) \

  2181.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));

  2182. 

  2183. #define sk_X509_ALGOR_value(sk, i) \

  2184.   ((X509_ALGOR *)sk_value(         \

  2185.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))

  2186. 

  2187. #define sk_X509_ALGOR_set(sk, i, p)                                         \

  2188.   ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2189.                         (i), CHECKED_CAST(void *, X509_ALGOR *, p)))

  2190. 

  2191. #define sk_X509_ALGOR_free(sk) \

  2192.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2193. 

  2194. #define sk_X509_ALGOR_pop_free(sk, free_func)             \

  2195.   sk_pop_free(                                            \

  2196.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2197.       CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))

  2198. 

  2199. #define sk_X509_ALGOR_insert(sk, p, where)                      \

  2200.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2201.             CHECKED_CAST(void *, X509_ALGOR *, p), (where))

  2202. 

  2203. #define sk_X509_ALGOR_delete(sk, where)                                        \

  2204.   ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2205.                            (where)))

  2206. 

  2207. #define sk_X509_ALGOR_delete_ptr(sk, p)                   \

  2208.   ((X509_ALGOR *)sk_delete_ptr(                           \

  2209.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2210.       CHECKED_CAST(void *, X509_ALGOR *, p)))

  2211. 

  2212. #define sk_X509_ALGOR_find(sk, out_index, p)                               \

  2213.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \

  2214.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2215. 

  2216. #define sk_X509_ALGOR_shift(sk) \

  2217.   ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2218. 

  2219. #define sk_X509_ALGOR_push(sk, p)                             \

  2220.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \

  2221.           CHECKED_CAST(void *, X509_ALGOR *, p))

  2222. 

  2223. #define sk_X509_ALGOR_pop(sk) \

  2224.   ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))

  2225. 

  2226. #define sk_X509_ALGOR_dup(sk)      \

  2227.   ((STACK_OF(X509_ALGOR) *)sk_dup( \

  2228.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk)))

  2229. 

  2230. #define sk_X509_ALGOR_sort(sk) \

  2231.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))

  2232. 

  2233. #define sk_X509_ALGOR_is_sorted(sk) \

  2234.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ALGOR) *, sk))

  2235. 

  2236. #define sk_X509_ALGOR_set_cmp_func(sk, comp)                             \

  2237.   ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \

  2238.       CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk),                \

  2239.       CHECKED_CAST(stack_cmp_func,                                       \

  2240.                    int (*)(const X509_ALGOR **a, const X509_ALGOR **b),  \

  2241.                    comp)))

  2242. 

  2243. 

  2244. /* X509_ATTRIBUTE */

  2245. #define sk_X509_ATTRIBUTE_new(comp)                 \

  2246.   ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \

  2247.       stack_cmp_func,                               \

  2248.       int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))

  2249. 

  2250. #define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())

  2251. 

  2252. #define sk_X509_ATTRIBUTE_num(sk) \

  2253.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2254. 

  2255. #define sk_X509_ATTRIBUTE_zero(sk) \

  2256.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));

  2257. 

  2258. #define sk_X509_ATTRIBUTE_value(sk, i) \

  2259.   ((X509_ATTRIBUTE *)sk_value(         \

  2260.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), (i)))

  2261. 

  2262. #define sk_X509_ATTRIBUTE_set(sk, i, p)                            \

  2263.   ((X509_ATTRIBUTE *)sk_set(                                       \

  2264.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \

  2265.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2266. 

  2267. #define sk_X509_ATTRIBUTE_free(sk) \

  2268.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2269. 

  2270. #define sk_X509_ATTRIBUTE_pop_free(sk, free_func)             \

  2271.   sk_pop_free(                                                \

  2272.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2273.       CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))

  2274. 

  2275. #define sk_X509_ATTRIBUTE_insert(sk, p, where)                      \

  2276.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2277.             CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))

  2278. 

  2279. #define sk_X509_ATTRIBUTE_delete(sk, where) \

  2280.   ((X509_ATTRIBUTE *)sk_delete(             \

  2281.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))

  2282. 

  2283. #define sk_X509_ATTRIBUTE_delete_ptr(sk, p)                   \

  2284.   ((X509_ATTRIBUTE *)sk_delete_ptr(                           \

  2285.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2286.       CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

  2287. 

  2288. #define sk_X509_ATTRIBUTE_find(sk, out_index, p)                               \

  2289.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \

  2290.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2291. 

  2292. #define sk_X509_ATTRIBUTE_shift(sk) \

  2293.   ((X509_ATTRIBUTE *)sk_shift(      \

  2294.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2295. 

  2296. #define sk_X509_ATTRIBUTE_push(sk, p)                             \

  2297.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \

  2298.           CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

  2299. 

  2300. #define sk_X509_ATTRIBUTE_pop(sk) \

  2301.   ((X509_ATTRIBUTE *)sk_pop(      \

  2302.       CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

  2303. 

  2304. #define sk_X509_ATTRIBUTE_dup(sk)      \

  2305.   ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \

  2306.       CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))

  2307. 

  2308. #define sk_X509_ATTRIBUTE_sort(sk) \

  2309.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))

  2310. 

  2311. #define sk_X509_ATTRIBUTE_is_sorted(sk) \

  2312.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

  2313. 

  2314. #define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp)                       \

  2315.   ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b))       \

  2316.    sk_set_cmp_func(                                                    \

  2317.        CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk),         \

  2318.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a,  \

  2319.                                             const X509_ATTRIBUTE **b), \

  2320.                     comp)))

  2321. 

  2322. 

  2323. /* X509_CRL */

  2324. #define sk_X509_CRL_new(comp)                 \

  2325.   ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \

  2326.       stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2327. 

  2328. #define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null())

  2329. 

  2330. #define sk_X509_CRL_num(sk) \

  2331.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2332. 

  2333. #define sk_X509_CRL_zero(sk) \

  2334.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));

  2335. 

  2336. #define sk_X509_CRL_value(sk, i) \

  2337.   ((X509_CRL *)sk_value(         \

  2338.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk), (i)))

  2339. 

  2340. #define sk_X509_CRL_set(sk, i, p)                                            \

  2341.   ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \

  2342.                       CHECKED_CAST(void *, X509_CRL *, p)))

  2343. 

  2344. #define sk_X509_CRL_free(sk) \

  2345.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2346. 

  2347. #define sk_X509_CRL_pop_free(sk, free_func)                     \

  2348.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2349.               CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))

  2350. 

  2351. #define sk_X509_CRL_insert(sk, p, where)                      \

  2352.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2353.             CHECKED_CAST(void *, X509_CRL *, p), (where))

  2354. 

  2355. #define sk_X509_CRL_delete(sk, where)                                      \

  2356.   ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2357.                          (where)))

  2358. 

  2359. #define sk_X509_CRL_delete_ptr(sk, p)                                          \

  2360.   ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2361.                              CHECKED_CAST(void *, X509_CRL *, p)))

  2362. 

  2363. #define sk_X509_CRL_find(sk, out_index, p)                               \

  2364.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \

  2365.           CHECKED_CAST(void *, X509_CRL *, p))

  2366. 

  2367. #define sk_X509_CRL_shift(sk) \

  2368.   ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2369. 

  2370. #define sk_X509_CRL_push(sk, p)                             \

  2371.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \

  2372.           CHECKED_CAST(void *, X509_CRL *, p))

  2373. 

  2374. #define sk_X509_CRL_pop(sk) \

  2375.   ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))

  2376. 

  2377. #define sk_X509_CRL_dup(sk)      \

  2378.   ((STACK_OF(X509_CRL) *)sk_dup( \

  2379.       CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk)))

  2380. 

  2381. #define sk_X509_CRL_sort(sk) \

  2382.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))

  2383. 

  2384. #define sk_X509_CRL_is_sorted(sk) \

  2385.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_CRL) *, sk))

  2386. 

  2387. #define sk_X509_CRL_set_cmp_func(sk, comp)                           \

  2388.   ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \

  2389.       CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk),              \

  2390.       CHECKED_CAST(stack_cmp_func,                                   \

  2391.                    int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

  2392. 

  2393. 

  2394. /* X509_EXTENSION */

  2395. #define sk_X509_EXTENSION_new(comp)                 \

  2396.   ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \

  2397.       stack_cmp_func,                               \

  2398.       int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))

  2399. 

  2400. #define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null())

  2401. 

  2402. #define sk_X509_EXTENSION_num(sk) \

  2403.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2404. 

  2405. #define sk_X509_EXTENSION_zero(sk) \

  2406.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));

  2407. 

  2408. #define sk_X509_EXTENSION_value(sk, i) \

  2409.   ((X509_EXTENSION *)sk_value(         \

  2410.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk), (i)))

  2411. 

  2412. #define sk_X509_EXTENSION_set(sk, i, p)                            \

  2413.   ((X509_EXTENSION *)sk_set(                                       \

  2414.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \

  2415.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2416. 

  2417. #define sk_X509_EXTENSION_free(sk) \

  2418.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2419. 

  2420. #define sk_X509_EXTENSION_pop_free(sk, free_func)             \

  2421.   sk_pop_free(                                                \

  2422.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2423.       CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))

  2424. 

  2425. #define sk_X509_EXTENSION_insert(sk, p, where)                      \

  2426.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2427.             CHECKED_CAST(void *, X509_EXTENSION *, p), (where))

  2428. 

  2429. #define sk_X509_EXTENSION_delete(sk, where) \

  2430.   ((X509_EXTENSION *)sk_delete(             \

  2431.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))

  2432. 

  2433. #define sk_X509_EXTENSION_delete_ptr(sk, p)                   \

  2434.   ((X509_EXTENSION *)sk_delete_ptr(                           \

  2435.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2436.       CHECKED_CAST(void *, X509_EXTENSION *, p)))

  2437. 

  2438. #define sk_X509_EXTENSION_find(sk, out_index, p)                               \

  2439.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \

  2440.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2441. 

  2442. #define sk_X509_EXTENSION_shift(sk) \

  2443.   ((X509_EXTENSION *)sk_shift(      \

  2444.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2445. 

  2446. #define sk_X509_EXTENSION_push(sk, p)                             \

  2447.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \

  2448.           CHECKED_CAST(void *, X509_EXTENSION *, p))

  2449. 

  2450. #define sk_X509_EXTENSION_pop(sk) \

  2451.   ((X509_EXTENSION *)sk_pop(      \

  2452.       CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

  2453. 

  2454. #define sk_X509_EXTENSION_dup(sk)      \

  2455.   ((STACK_OF(X509_EXTENSION) *)sk_dup( \

  2456.       CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk)))

  2457. 

  2458. #define sk_X509_EXTENSION_sort(sk) \

  2459.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))

  2460. 

  2461. #define sk_X509_EXTENSION_is_sorted(sk) \

  2462.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_EXTENSION) *, sk))

  2463. 

  2464. #define sk_X509_EXTENSION_set_cmp_func(sk, comp)                       \

  2465.   ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b))       \

  2466.    sk_set_cmp_func(                                                    \

  2467.        CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk),         \

  2468.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a,  \

  2469.                                             const X509_EXTENSION **b), \

  2470.                     comp)))

  2471. 

  2472. 

  2473. /* X509_INFO */

  2474. #define sk_X509_INFO_new(comp)     \

  2475.   ((STACK_OF(X509_INFO) *)sk_new(  \

  2476.       CHECKED_CAST(stack_cmp_func, \

  2477.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2478. 

  2479. #define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null())

  2480. 

  2481. #define sk_X509_INFO_num(sk) \

  2482.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2483. 

  2484. #define sk_X509_INFO_zero(sk) \

  2485.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));

  2486. 

  2487. #define sk_X509_INFO_value(sk, i) \

  2488.   ((X509_INFO *)sk_value(         \

  2489.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk), (i)))

  2490. 

  2491. #define sk_X509_INFO_set(sk, i, p)                                             \

  2492.   ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \

  2493.                        CHECKED_CAST(void *, X509_INFO *, p)))

  2494. 

  2495. #define sk_X509_INFO_free(sk) \

  2496.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2497. 

  2498. #define sk_X509_INFO_pop_free(sk, free_func)             \

  2499.   sk_pop_free(                                           \

  2500.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2501.       CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))

  2502. 

  2503. #define sk_X509_INFO_insert(sk, p, where)                      \

  2504.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2505.             CHECKED_CAST(void *, X509_INFO *, p), (where))

  2506. 

  2507. #define sk_X509_INFO_delete(sk, where)                                       \

  2508.   ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2509.                           (where)))

  2510. 

  2511. #define sk_X509_INFO_delete_ptr(sk, p)                   \

  2512.   ((X509_INFO *)sk_delete_ptr(                           \

  2513.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2514.       CHECKED_CAST(void *, X509_INFO *, p)))

  2515. 

  2516. #define sk_X509_INFO_find(sk, out_index, p)                               \

  2517.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \

  2518.           CHECKED_CAST(void *, X509_INFO *, p))

  2519. 

  2520. #define sk_X509_INFO_shift(sk) \

  2521.   ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2522. 

  2523. #define sk_X509_INFO_push(sk, p)                             \

  2524.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \

  2525.           CHECKED_CAST(void *, X509_INFO *, p))

  2526. 

  2527. #define sk_X509_INFO_pop(sk) \

  2528.   ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))

  2529. 

  2530. #define sk_X509_INFO_dup(sk)      \

  2531.   ((STACK_OF(X509_INFO) *)sk_dup( \

  2532.       CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk)))

  2533. 

  2534. #define sk_X509_INFO_sort(sk) \

  2535.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))

  2536. 

  2537. #define sk_X509_INFO_is_sorted(sk) \

  2538.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_INFO) *, sk))

  2539. 

  2540. #define sk_X509_INFO_set_cmp_func(sk, comp)                            \

  2541.   ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \

  2542.       CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk),               \

  2543.       CHECKED_CAST(stack_cmp_func,                                     \

  2544.                    int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

  2545. 

  2546. 

  2547. /* X509_LOOKUP */

  2548. #define sk_X509_LOOKUP_new(comp)                                             \

  2549.   ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST(                             \

  2550.       stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \

  2551.       comp)))

  2552. 

  2553. #define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null())

  2554. 

  2555. #define sk_X509_LOOKUP_num(sk) \

  2556.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2557. 

  2558. #define sk_X509_LOOKUP_zero(sk) \

  2559.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));

  2560. 

  2561. #define sk_X509_LOOKUP_value(sk, i) \

  2562.   ((X509_LOOKUP *)sk_value(         \

  2563.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))

  2564. 

  2565. #define sk_X509_LOOKUP_set(sk, i, p)                                          \

  2566.   ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2567.                          (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2568. 

  2569. #define sk_X509_LOOKUP_free(sk) \

  2570.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2571. 

  2572. #define sk_X509_LOOKUP_pop_free(sk, free_func)             \

  2573.   sk_pop_free(                                             \

  2574.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2575.       CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))

  2576. 

  2577. #define sk_X509_LOOKUP_insert(sk, p, where)                      \

  2578.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2579.             CHECKED_CAST(void *, X509_LOOKUP *, p), (where))

  2580. 

  2581. #define sk_X509_LOOKUP_delete(sk, where) \

  2582.   ((X509_LOOKUP *)sk_delete(             \

  2583.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))

  2584. 

  2585. #define sk_X509_LOOKUP_delete_ptr(sk, p)                   \

  2586.   ((X509_LOOKUP *)sk_delete_ptr(                           \

  2587.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2588.       CHECKED_CAST(void *, X509_LOOKUP *, p)))

  2589. 

  2590. #define sk_X509_LOOKUP_find(sk, out_index, p)                               \

  2591.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \

  2592.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2593. 

  2594. #define sk_X509_LOOKUP_shift(sk) \

  2595.   ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2596. 

  2597. #define sk_X509_LOOKUP_push(sk, p)                             \

  2598.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \

  2599.           CHECKED_CAST(void *, X509_LOOKUP *, p))

  2600. 

  2601. #define sk_X509_LOOKUP_pop(sk) \

  2602.   ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))

  2603. 

  2604. #define sk_X509_LOOKUP_dup(sk)      \

  2605.   ((STACK_OF(X509_LOOKUP) *)sk_dup( \

  2606.       CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk)))

  2607. 

  2608. #define sk_X509_LOOKUP_sort(sk) \

  2609.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))

  2610. 

  2611. #define sk_X509_LOOKUP_is_sorted(sk) \

  2612.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_LOOKUP) *, sk))

  2613. 

  2614. #define sk_X509_LOOKUP_set_cmp_func(sk, comp)                              \

  2615.   ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \

  2616.       CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk),                 \

  2617.       CHECKED_CAST(stack_cmp_func,                                         \

  2618.                    int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b),  \

  2619.                    comp)))

  2620. 

  2621. 

  2622. /* X509_NAME */

  2623. #define sk_X509_NAME_new(comp)     \

  2624.   ((STACK_OF(X509_NAME) *)sk_new(  \

  2625.       CHECKED_CAST(stack_cmp_func, \

  2626.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2627. 

  2628. #define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null())

  2629. 

  2630. #define sk_X509_NAME_num(sk) \

  2631.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2632. 

  2633. #define sk_X509_NAME_zero(sk) \

  2634.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));

  2635. 

  2636. #define sk_X509_NAME_value(sk, i) \

  2637.   ((X509_NAME *)sk_value(         \

  2638.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk), (i)))

  2639. 

  2640. #define sk_X509_NAME_set(sk, i, p)                                             \

  2641.   ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \

  2642.                        CHECKED_CAST(void *, X509_NAME *, p)))

  2643. 

  2644. #define sk_X509_NAME_free(sk) \

  2645.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2646. 

  2647. #define sk_X509_NAME_pop_free(sk, free_func)             \

  2648.   sk_pop_free(                                           \

  2649.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2650.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))

  2651. 

  2652. #define sk_X509_NAME_insert(sk, p, where)                      \

  2653.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2654.             CHECKED_CAST(void *, X509_NAME *, p), (where))

  2655. 

  2656. #define sk_X509_NAME_delete(sk, where)                                       \

  2657.   ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2658.                           (where)))

  2659. 

  2660. #define sk_X509_NAME_delete_ptr(sk, p)                   \

  2661.   ((X509_NAME *)sk_delete_ptr(                           \

  2662.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2663.       CHECKED_CAST(void *, X509_NAME *, p)))

  2664. 

  2665. #define sk_X509_NAME_find(sk, out_index, p)                               \

  2666.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \

  2667.           CHECKED_CAST(void *, X509_NAME *, p))

  2668. 

  2669. #define sk_X509_NAME_shift(sk) \

  2670.   ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2671. 

  2672. #define sk_X509_NAME_push(sk, p)                             \

  2673.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \

  2674.           CHECKED_CAST(void *, X509_NAME *, p))

  2675. 

  2676. #define sk_X509_NAME_pop(sk) \

  2677.   ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))

  2678. 

  2679. #define sk_X509_NAME_dup(sk)      \

  2680.   ((STACK_OF(X509_NAME) *)sk_dup( \

  2681.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk)))

  2682. 

  2683. #define sk_X509_NAME_sort(sk) \

  2684.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))

  2685. 

  2686. #define sk_X509_NAME_is_sorted(sk) \

  2687.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME) *, sk))

  2688. 

  2689. #define sk_X509_NAME_set_cmp_func(sk, comp)                            \

  2690.   ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \

  2691.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk),               \

  2692.       CHECKED_CAST(stack_cmp_func,                                     \

  2693.                    int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

  2694. 

  2695. 

  2696. /* X509_NAME_ENTRY */

  2697. #define sk_X509_NAME_ENTRY_new(comp)                 \

  2698.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \

  2699.       stack_cmp_func,                                \

  2700.       int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))

  2701. 

  2702. #define sk_X509_NAME_ENTRY_new_null() \

  2703.   ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())

  2704. 

  2705. #define sk_X509_NAME_ENTRY_num(sk) \

  2706.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2707. 

  2708. #define sk_X509_NAME_ENTRY_zero(sk) \

  2709.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));

  2710. 

  2711. #define sk_X509_NAME_ENTRY_value(sk, i) \

  2712.   ((X509_NAME_ENTRY *)sk_value(         \

  2713.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), (i)))

  2714. 

  2715. #define sk_X509_NAME_ENTRY_set(sk, i, p)                            \

  2716.   ((X509_NAME_ENTRY *)sk_set(                                       \

  2717.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \

  2718.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  2719. 

  2720. #define sk_X509_NAME_ENTRY_free(sk) \

  2721.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2722. 

  2723. #define sk_X509_NAME_ENTRY_pop_free(sk, free_func)             \

  2724.   sk_pop_free(                                                 \

  2725.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2726.       CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))

  2727. 

  2728. #define sk_X509_NAME_ENTRY_insert(sk, p, where)                      \

  2729.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2730.             CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))

  2731. 

  2732. #define sk_X509_NAME_ENTRY_delete(sk, where) \

  2733.   ((X509_NAME_ENTRY *)sk_delete(             \

  2734.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))

  2735. 

  2736. #define sk_X509_NAME_ENTRY_delete_ptr(sk, p)                   \

  2737.   ((X509_NAME_ENTRY *)sk_delete_ptr(                           \

  2738.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2739.       CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

  2740. 

  2741. #define sk_X509_NAME_ENTRY_find(sk, out_index, p)                  \

  2742.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2743.           (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  2744. 

  2745. #define sk_X509_NAME_ENTRY_shift(sk) \

  2746.   ((X509_NAME_ENTRY *)sk_shift(      \

  2747.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  2748. 

  2749. #define sk_X509_NAME_ENTRY_push(sk, p)                             \

  2750.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \

  2751.           CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

  2752. 

  2753. #define sk_X509_NAME_ENTRY_pop(sk) \

  2754.   ((X509_NAME_ENTRY *)sk_pop(      \

  2755.       CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

  2756. 

  2757. #define sk_X509_NAME_ENTRY_dup(sk)      \

  2758.   ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \

  2759.       CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))

  2760. 

  2761. #define sk_X509_NAME_ENTRY_sort(sk) \

  2762.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))

  2763. 

  2764. #define sk_X509_NAME_ENTRY_is_sorted(sk) \

  2765.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

  2766. 

  2767. #define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp)                       \

  2768.   ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b))      \

  2769.    sk_set_cmp_func(                                                     \

  2770.        CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk),         \

  2771.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a,  \

  2772.                                             const X509_NAME_ENTRY **b), \

  2773.                     comp)))

  2774. 

  2775. 

  2776. /* X509_OBJECT */

  2777. #define sk_X509_OBJECT_new(comp)                                             \

  2778.   ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST(                             \

  2779.       stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \

  2780.       comp)))

  2781. 

  2782. #define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null())

  2783. 

  2784. #define sk_X509_OBJECT_num(sk) \

  2785.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2786. 

  2787. #define sk_X509_OBJECT_zero(sk) \

  2788.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));

  2789. 

  2790. #define sk_X509_OBJECT_value(sk, i) \

  2791.   ((X509_OBJECT *)sk_value(         \

  2792.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))

  2793. 

  2794. #define sk_X509_OBJECT_set(sk, i, p)                                          \

  2795.   ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2796.                          (i), CHECKED_CAST(void *, X509_OBJECT *, p)))

  2797. 

  2798. #define sk_X509_OBJECT_free(sk) \

  2799.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2800. 

  2801. #define sk_X509_OBJECT_pop_free(sk, free_func)             \

  2802.   sk_pop_free(                                             \

  2803.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2804.       CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))

  2805. 

  2806. #define sk_X509_OBJECT_insert(sk, p, where)                      \

  2807.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2808.             CHECKED_CAST(void *, X509_OBJECT *, p), (where))

  2809. 

  2810. #define sk_X509_OBJECT_delete(sk, where) \

  2811.   ((X509_OBJECT *)sk_delete(             \

  2812.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))

  2813. 

  2814. #define sk_X509_OBJECT_delete_ptr(sk, p)                   \

  2815.   ((X509_OBJECT *)sk_delete_ptr(                           \

  2816.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2817.       CHECKED_CAST(void *, X509_OBJECT *, p)))

  2818. 

  2819. #define sk_X509_OBJECT_find(sk, out_index, p)                               \

  2820.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \

  2821.           CHECKED_CAST(void *, X509_OBJECT *, p))

  2822. 

  2823. #define sk_X509_OBJECT_shift(sk) \

  2824.   ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  2825. 

  2826. #define sk_X509_OBJECT_push(sk, p)                             \

  2827.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \

  2828.           CHECKED_CAST(void *, X509_OBJECT *, p))

  2829. 

  2830. #define sk_X509_OBJECT_pop(sk) \

  2831.   ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

  2832. 

  2833. #define sk_X509_OBJECT_dup(sk)      \

  2834.   ((STACK_OF(X509_OBJECT) *)sk_dup( \

  2835.       CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk)))

  2836. 

  2837. #define sk_X509_OBJECT_sort(sk) \

  2838.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

  2839. 

  2840. #define sk_X509_OBJECT_is_sorted(sk) \

  2841.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_OBJECT) *, sk))

  2842. 

  2843. #define sk_X509_OBJECT_set_cmp_func(sk, comp)                              \

  2844.   ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \

  2845.       CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk),                 \

  2846.       CHECKED_CAST(stack_cmp_func,                                         \

  2847.                    int (*)(const X509_OBJECT **a, const X509_OBJECT **b),  \

  2848.                    comp)))

  2849. 

  2850. 

  2851. /* X509_POLICY_DATA */

  2852. #define sk_X509_POLICY_DATA_new(comp)                 \

  2853.   ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \

  2854.       stack_cmp_func,                                 \

  2855.       int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))

  2856. 

  2857. #define sk_X509_POLICY_DATA_new_null() \

  2858.   ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())

  2859. 

  2860. #define sk_X509_POLICY_DATA_num(sk) \

  2861.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  2862. 

  2863. #define sk_X509_POLICY_DATA_zero(sk) \

  2864.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));

  2865. 

  2866. #define sk_X509_POLICY_DATA_value(sk, i) \

  2867.   ((X509_POLICY_DATA *)sk_value(         \

  2868.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), (i)))

  2869. 

  2870. #define sk_X509_POLICY_DATA_set(sk, i, p)                            \

  2871.   ((X509_POLICY_DATA *)sk_set(                                       \

  2872.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \

  2873.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  2874. 

  2875. #define sk_X509_POLICY_DATA_free(sk) \

  2876.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  2877. 

  2878. #define sk_X509_POLICY_DATA_pop_free(sk, free_func)             \

  2879.   sk_pop_free(                                                  \

  2880.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  2881.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))

  2882. 

  2883. #define sk_X509_POLICY_DATA_insert(sk, p, where)                      \

  2884.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  2885.             CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))

  2886. 

  2887. #define sk_X509_POLICY_DATA_delete(sk, where) \

  2888.   ((X509_POLICY_DATA *)sk_delete(             \

  2889.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))

  2890. 

  2891. #define sk_X509_POLICY_DATA_delete_ptr(sk, p)                   \

  2892.   ((X509_POLICY_DATA *)sk_delete_ptr(                           \

  2893.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  2894.       CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

  2895. 

  2896. #define sk_X509_POLICY_DATA_find(sk, out_index, p)                  \

  2897.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  2898.           (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  2899. 

  2900. #define sk_X509_POLICY_DATA_shift(sk) \

  2901.   ((X509_POLICY_DATA *)sk_shift(      \

  2902.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  2903. 

  2904. #define sk_X509_POLICY_DATA_push(sk, p)                             \

  2905.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \

  2906.           CHECKED_CAST(void *, X509_POLICY_DATA *, p))

  2907. 

  2908. #define sk_X509_POLICY_DATA_pop(sk) \

  2909.   ((X509_POLICY_DATA *)sk_pop(      \

  2910.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

  2911. 

  2912. #define sk_X509_POLICY_DATA_dup(sk)      \

  2913.   ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \

  2914.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))

  2915. 

  2916. #define sk_X509_POLICY_DATA_sort(sk) \

  2917.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

  2918. 

  2919. #define sk_X509_POLICY_DATA_is_sorted(sk) \

  2920.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

  2921. 

  2922. #define sk_X509_POLICY_DATA_set_cmp_func(sk, comp)                       \

  2923.   ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b))     \

  2924.    sk_set_cmp_func(                                                      \

  2925.        CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk),         \

  2926.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a,  \

  2927.                                             const X509_POLICY_DATA **b), \

  2928.                     comp)))

  2929. 

  2930. 

  2931. /* X509_POLICY_NODE */

  2932. #define sk_X509_POLICY_NODE_new(comp)                 \

  2933.   ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \

  2934.       stack_cmp_func,                                 \

  2935.       int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))

  2936. 

  2937. #define sk_X509_POLICY_NODE_new_null() \

  2938.   ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())

  2939. 

  2940. #define sk_X509_POLICY_NODE_num(sk) \

  2941.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  2942. 

  2943. #define sk_X509_POLICY_NODE_zero(sk) \

  2944.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));

  2945. 

  2946. #define sk_X509_POLICY_NODE_value(sk, i) \

  2947.   ((X509_POLICY_NODE *)sk_value(         \

  2948.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), (i)))

  2949. 

  2950. #define sk_X509_POLICY_NODE_set(sk, i, p)                            \

  2951.   ((X509_POLICY_NODE *)sk_set(                                       \

  2952.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \

  2953.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  2954. 

  2955. #define sk_X509_POLICY_NODE_free(sk) \

  2956.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  2957. 

  2958. #define sk_X509_POLICY_NODE_pop_free(sk, free_func)             \

  2959.   sk_pop_free(                                                  \

  2960.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  2961.       CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))

  2962. 

  2963. #define sk_X509_POLICY_NODE_insert(sk, p, where)                      \

  2964.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  2965.             CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))

  2966. 

  2967. #define sk_X509_POLICY_NODE_delete(sk, where) \

  2968.   ((X509_POLICY_NODE *)sk_delete(             \

  2969.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))

  2970. 

  2971. #define sk_X509_POLICY_NODE_delete_ptr(sk, p)                   \

  2972.   ((X509_POLICY_NODE *)sk_delete_ptr(                           \

  2973.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  2974.       CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

  2975. 

  2976. #define sk_X509_POLICY_NODE_find(sk, out_index, p)                  \

  2977.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  2978.           (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  2979. 

  2980. #define sk_X509_POLICY_NODE_shift(sk) \

  2981.   ((X509_POLICY_NODE *)sk_shift(      \

  2982.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  2983. 

  2984. #define sk_X509_POLICY_NODE_push(sk, p)                             \

  2985.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \

  2986.           CHECKED_CAST(void *, X509_POLICY_NODE *, p))

  2987. 

  2988. #define sk_X509_POLICY_NODE_pop(sk) \

  2989.   ((X509_POLICY_NODE *)sk_pop(      \

  2990.       CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

  2991. 

  2992. #define sk_X509_POLICY_NODE_dup(sk)      \

  2993.   ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \

  2994.       CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))

  2995. 

  2996. #define sk_X509_POLICY_NODE_sort(sk) \

  2997.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

  2998. 

  2999. #define sk_X509_POLICY_NODE_is_sorted(sk) \

  3000.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

  3001. 

  3002. #define sk_X509_POLICY_NODE_set_cmp_func(sk, comp)                       \

  3003.   ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b))     \

  3004.    sk_set_cmp_func(                                                      \

  3005.        CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk),         \

  3006.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a,  \

  3007.                                             const X509_POLICY_NODE **b), \

  3008.                     comp)))

  3009. 

  3010. 

  3011. /* X509_PURPOSE */

  3012. #define sk_X509_PURPOSE_new(comp)                                              \

  3013.   ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST(                              \

  3014.       stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \

  3015.       comp)))

  3016. 

  3017. #define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null())

  3018. 

  3019. #define sk_X509_PURPOSE_num(sk) \

  3020.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3021. 

  3022. #define sk_X509_PURPOSE_zero(sk) \

  3023.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));

  3024. 

  3025. #define sk_X509_PURPOSE_value(sk, i) \

  3026.   ((X509_PURPOSE *)sk_value(         \

  3027.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))

  3028. 

  3029. #define sk_X509_PURPOSE_set(sk, i, p)                            \

  3030.   ((X509_PURPOSE *)sk_set(                                       \

  3031.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \

  3032.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3033. 

  3034. #define sk_X509_PURPOSE_free(sk) \

  3035.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3036. 

  3037. #define sk_X509_PURPOSE_pop_free(sk, free_func)             \

  3038.   sk_pop_free(                                              \

  3039.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3040.       CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))

  3041. 

  3042. #define sk_X509_PURPOSE_insert(sk, p, where)                      \

  3043.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3044.             CHECKED_CAST(void *, X509_PURPOSE *, p), (where))

  3045. 

  3046. #define sk_X509_PURPOSE_delete(sk, where) \

  3047.   ((X509_PURPOSE *)sk_delete(             \

  3048.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))

  3049. 

  3050. #define sk_X509_PURPOSE_delete_ptr(sk, p)                   \

  3051.   ((X509_PURPOSE *)sk_delete_ptr(                           \

  3052.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3053.       CHECKED_CAST(void *, X509_PURPOSE *, p)))

  3054. 

  3055. #define sk_X509_PURPOSE_find(sk, out_index, p)                               \

  3056.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \

  3057.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3058. 

  3059. #define sk_X509_PURPOSE_shift(sk) \

  3060.   ((X509_PURPOSE *)sk_shift(      \

  3061.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3062. 

  3063. #define sk_X509_PURPOSE_push(sk, p)                             \

  3064.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \

  3065.           CHECKED_CAST(void *, X509_PURPOSE *, p))

  3066. 

  3067. #define sk_X509_PURPOSE_pop(sk) \

  3068.   ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

  3069. 

  3070. #define sk_X509_PURPOSE_dup(sk)      \

  3071.   ((STACK_OF(X509_PURPOSE) *)sk_dup( \

  3072.       CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk)))

  3073. 

  3074. #define sk_X509_PURPOSE_sort(sk) \

  3075.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

  3076. 

  3077. #define sk_X509_PURPOSE_is_sorted(sk) \

  3078.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_PURPOSE) *, sk))

  3079. 

  3080. #define sk_X509_PURPOSE_set_cmp_func(sk, comp)                               \

  3081.   ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \

  3082.       CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk),                  \

  3083.       CHECKED_CAST(stack_cmp_func,                                           \

  3084.                    int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b),  \

  3085.                    comp)))

  3086. 

  3087. 

  3088. /* X509_REVOKED */

  3089. #define sk_X509_REVOKED_new(comp)                                              \

  3090.   ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST(                              \

  3091.       stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \

  3092.       comp)))

  3093. 

  3094. #define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null())

  3095. 

  3096. #define sk_X509_REVOKED_num(sk) \

  3097.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3098. 

  3099. #define sk_X509_REVOKED_zero(sk) \

  3100.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));

  3101. 

  3102. #define sk_X509_REVOKED_value(sk, i) \

  3103.   ((X509_REVOKED *)sk_value(         \

  3104.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))

  3105. 

  3106. #define sk_X509_REVOKED_set(sk, i, p)                            \

  3107.   ((X509_REVOKED *)sk_set(                                       \

  3108.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \

  3109.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3110. 

  3111. #define sk_X509_REVOKED_free(sk) \

  3112.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3113. 

  3114. #define sk_X509_REVOKED_pop_free(sk, free_func)             \

  3115.   sk_pop_free(                                              \

  3116.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3117.       CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))

  3118. 

  3119. #define sk_X509_REVOKED_insert(sk, p, where)                      \

  3120.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3121.             CHECKED_CAST(void *, X509_REVOKED *, p), (where))

  3122. 

  3123. #define sk_X509_REVOKED_delete(sk, where) \

  3124.   ((X509_REVOKED *)sk_delete(             \

  3125.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))

  3126. 

  3127. #define sk_X509_REVOKED_delete_ptr(sk, p)                   \

  3128.   ((X509_REVOKED *)sk_delete_ptr(                           \

  3129.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3130.       CHECKED_CAST(void *, X509_REVOKED *, p)))

  3131. 

  3132. #define sk_X509_REVOKED_find(sk, out_index, p)                               \

  3133.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \

  3134.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3135. 

  3136. #define sk_X509_REVOKED_shift(sk) \

  3137.   ((X509_REVOKED *)sk_shift(      \

  3138.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3139. 

  3140. #define sk_X509_REVOKED_push(sk, p)                             \

  3141.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \

  3142.           CHECKED_CAST(void *, X509_REVOKED *, p))

  3143. 

  3144. #define sk_X509_REVOKED_pop(sk) \

  3145.   ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

  3146. 

  3147. #define sk_X509_REVOKED_dup(sk)      \

  3148.   ((STACK_OF(X509_REVOKED) *)sk_dup( \

  3149.       CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk)))

  3150. 

  3151. #define sk_X509_REVOKED_sort(sk) \

  3152.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

  3153. 

  3154. #define sk_X509_REVOKED_is_sorted(sk) \

  3155.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_REVOKED) *, sk))

  3156. 

  3157. #define sk_X509_REVOKED_set_cmp_func(sk, comp)                               \

  3158.   ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \

  3159.       CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk),                  \

  3160.       CHECKED_CAST(stack_cmp_func,                                           \

  3161.                    int (*)(const X509_REVOKED **a, const X509_REVOKED **b),  \

  3162.                    comp)))

  3163. 

  3164. 

  3165. /* X509_TRUST */

  3166. #define sk_X509_TRUST_new(comp)                                            \

  3167.   ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST(                            \

  3168.       stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \

  3169.       comp)))

  3170. 

  3171. #define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null())

  3172. 

  3173. #define sk_X509_TRUST_num(sk) \

  3174.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3175. 

  3176. #define sk_X509_TRUST_zero(sk) \

  3177.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));

  3178. 

  3179. #define sk_X509_TRUST_value(sk, i) \

  3180.   ((X509_TRUST *)sk_value(         \

  3181.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))

  3182. 

  3183. #define sk_X509_TRUST_set(sk, i, p)                                         \

  3184.   ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3185.                         (i), CHECKED_CAST(void *, X509_TRUST *, p)))

  3186. 

  3187. #define sk_X509_TRUST_free(sk) \

  3188.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3189. 

  3190. #define sk_X509_TRUST_pop_free(sk, free_func)             \

  3191.   sk_pop_free(                                            \

  3192.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3193.       CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))

  3194. 

  3195. #define sk_X509_TRUST_insert(sk, p, where)                      \

  3196.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3197.             CHECKED_CAST(void *, X509_TRUST *, p), (where))

  3198. 

  3199. #define sk_X509_TRUST_delete(sk, where)                                        \

  3200.   ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3201.                            (where)))

  3202. 

  3203. #define sk_X509_TRUST_delete_ptr(sk, p)                   \

  3204.   ((X509_TRUST *)sk_delete_ptr(                           \

  3205.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3206.       CHECKED_CAST(void *, X509_TRUST *, p)))

  3207. 

  3208. #define sk_X509_TRUST_find(sk, out_index, p)                               \

  3209.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \

  3210.           CHECKED_CAST(void *, X509_TRUST *, p))

  3211. 

  3212. #define sk_X509_TRUST_shift(sk) \

  3213.   ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3214. 

  3215. #define sk_X509_TRUST_push(sk, p)                             \

  3216.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \

  3217.           CHECKED_CAST(void *, X509_TRUST *, p))

  3218. 

  3219. #define sk_X509_TRUST_pop(sk) \

  3220.   ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

  3221. 

  3222. #define sk_X509_TRUST_dup(sk)      \

  3223.   ((STACK_OF(X509_TRUST) *)sk_dup( \

  3224.       CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk)))

  3225. 

  3226. #define sk_X509_TRUST_sort(sk) \

  3227.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

  3228. 

  3229. #define sk_X509_TRUST_is_sorted(sk) \

  3230.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_TRUST) *, sk))

  3231. 

  3232. #define sk_X509_TRUST_set_cmp_func(sk, comp)                             \

  3233.   ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \

  3234.       CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk),                \

  3235.       CHECKED_CAST(stack_cmp_func,                                       \

  3236.                    int (*)(const X509_TRUST **a, const X509_TRUST **b),  \

  3237.                    comp)))

  3238. 

  3239. 

  3240. /* X509_VERIFY_PARAM */

  3241. #define sk_X509_VERIFY_PARAM_new(comp)                                   \

  3242.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST(                   \

  3243.       stack_cmp_func,                                                    \

  3244.       int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \

  3245.       comp)))

  3246. 

  3247. #define sk_X509_VERIFY_PARAM_new_null() \

  3248.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())

  3249. 

  3250. #define sk_X509_VERIFY_PARAM_num(sk) \

  3251.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3252. 

  3253. #define sk_X509_VERIFY_PARAM_zero(sk) \

  3254.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));

  3255. 

  3256. #define sk_X509_VERIFY_PARAM_value(sk, i) \

  3257.   ((X509_VERIFY_PARAM *)sk_value(         \

  3258.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), (i)))

  3259. 

  3260. #define sk_X509_VERIFY_PARAM_set(sk, i, p)                            \

  3261.   ((X509_VERIFY_PARAM *)sk_set(                                       \

  3262.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \

  3263.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3264. 

  3265. #define sk_X509_VERIFY_PARAM_free(sk) \

  3266.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3267. 

  3268. #define sk_X509_VERIFY_PARAM_pop_free(sk, free_func)                        \

  3269.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),    \

  3270.               CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \

  3271.                            free_func))

  3272. 

  3273. #define sk_X509_VERIFY_PARAM_insert(sk, p, where)                      \

  3274.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3275.             CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))

  3276. 

  3277. #define sk_X509_VERIFY_PARAM_delete(sk, where) \

  3278.   ((X509_VERIFY_PARAM *)sk_delete(             \

  3279.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))

  3280. 

  3281. #define sk_X509_VERIFY_PARAM_delete_ptr(sk, p)                   \

  3282.   ((X509_VERIFY_PARAM *)sk_delete_ptr(                           \

  3283.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3284.       CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

  3285. 

  3286. #define sk_X509_VERIFY_PARAM_find(sk, out_index, p)                  \

  3287.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3288.           (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3289. 

  3290. #define sk_X509_VERIFY_PARAM_shift(sk) \

  3291.   ((X509_VERIFY_PARAM *)sk_shift(      \

  3292.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3293. 

  3294. #define sk_X509_VERIFY_PARAM_push(sk, p)                             \

  3295.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \

  3296.           CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

  3297. 

  3298. #define sk_X509_VERIFY_PARAM_pop(sk) \

  3299.   ((X509_VERIFY_PARAM *)sk_pop(      \

  3300.       CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3301. 

  3302. #define sk_X509_VERIFY_PARAM_dup(sk)      \

  3303.   ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \

  3304.       CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))

  3305. 

  3306. #define sk_X509_VERIFY_PARAM_sort(sk) \

  3307.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

  3308. 

  3309. #define sk_X509_VERIFY_PARAM_is_sorted(sk) \

  3310.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

  3311. 

  3312. #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp)                       \

  3313.   ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b))    \

  3314.    sk_set_cmp_func(                                                       \

  3315.        CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),         \

  3316.        CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a,  \

  3317.                                             const X509_VERIFY_PARAM **b), \

  3318.                     comp)))

  3319. 

  3320. 

  3321. /* void */

  3322. #define sk_void_new(comp)                \

  3323.   ((STACK_OF(void)*)sk_new(CHECKED_CAST( \

  3324.       stack_cmp_func, int (*)(const void **a, const void **b), comp)))

  3325. 

  3326. #define sk_void_new_null() ((STACK_OF(void)*)sk_new_null())

  3327. 

  3328. #define sk_void_num(sk) sk_num(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))

  3329. 

  3330. #define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk));

  3331. 

  3332. #define sk_void_value(sk, i) \

  3333.   ((void *)sk_value(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk), (i)))

  3334. 

  3335. #define sk_void_set(sk, i, p)                                       \

  3336.   ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (i), \

  3337.                   CHECKED_CAST(void *, void *, p)))

  3338. 

  3339. #define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))

  3340. 

  3341. #define sk_void_pop_free(sk, free_func)                    \

  3342.   sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3343.               CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))

  3344. 

  3345. #define sk_void_insert(sk, p, where)                     \

  3346.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3347.             CHECKED_CAST(void *, void *, p), (where))

  3348. 

  3349. #define sk_void_delete(sk, where) \

  3350.   ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (where)))

  3351. 

  3352. #define sk_void_delete_ptr(sk, p)                                     \

  3353.   ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3354.                          CHECKED_CAST(void *, void *, p)))

  3355. 

  3356. #define sk_void_find(sk, out_index, p)                              \

  3357.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), (out_index), \

  3358.           CHECKED_CAST(void *, void *, p))

  3359. 

  3360. #define sk_void_shift(sk) \

  3361.   ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3362. 

  3363. #define sk_void_push(sk, p)                            \

  3364.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk), \

  3365.           CHECKED_CAST(void *, void *, p))

  3366. 

  3367. #define sk_void_pop(sk) \

  3368.   ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk)))

  3369. 

  3370. #define sk_void_dup(sk) \

  3371.   ((STACK_OF(void)*)sk_dup(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk)))

  3372. 

  3373. #define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void)*, sk))

  3374. 

  3375. #define sk_void_is_sorted(sk) \

  3376.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(void)*, sk))

  3377. 

  3378. #define sk_void_set_cmp_func(sk, comp)                                      \

  3379.   ((int (*)(const void **a, const void **b))sk_set_cmp_func(                \

  3380.       CHECKED_CAST(_STACK *, STACK_OF(void)*, sk),                          \

  3381.       CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \

  3382.                    comp)))

  3383. 

  3384. 

  3385. /* SRTP_PROTECTION_PROFILE */

  3386. #define sk_SRTP_PROTECTION_PROFILE_new(comp)                            \

  3387.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST(            \

  3388.       stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a,  \

  3389.                               const const SRTP_PROTECTION_PROFILE **b), \

  3390.       comp)))

  3391. 

  3392. #define sk_SRTP_PROTECTION_PROFILE_new_null() \

  3393.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())

  3394. 

  3395. #define sk_SRTP_PROTECTION_PROFILE_num(sk) \

  3396.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3397. 

  3398. #define sk_SRTP_PROTECTION_PROFILE_zero(sk) \

  3399.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));

  3400. 

  3401. #define sk_SRTP_PROTECTION_PROFILE_value(sk, i)                              \

  3402.   ((const SRTP_PROTECTION_PROFILE *)sk_value(                                \

  3403.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3404.       (i)))

  3405. 

  3406. #define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p)                            \

  3407.   ((const SRTP_PROTECTION_PROFILE *)sk_set(                                 \

  3408.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \

  3409.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3410. 

  3411. #define sk_SRTP_PROTECTION_PROFILE_free(sk) \

  3412.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3413. 

  3414. #define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func)             \

  3415.   sk_pop_free(                                                         \

  3416.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3417.       CHECKED_CAST(void (*)(void *),                                   \

  3418.                    void (*)(const SRTP_PROTECTION_PROFILE *), free_func))

  3419. 

  3420. #define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where)                      \

  3421.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3422.             CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where))

  3423. 

  3424. #define sk_SRTP_PROTECTION_PROFILE_delete(sk, where)                   \

  3425.   ((const SRTP_PROTECTION_PROFILE *)sk_delete(                         \

  3426.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3427.       (where)))

  3428. 

  3429. #define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p)                   \

  3430.   ((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr(                     \

  3431.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3432.       CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

  3433. 

  3434. #define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p)                  \

  3435.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3436.           (out_index),                                                     \

  3437.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3438. 

  3439. #define sk_SRTP_PROTECTION_PROFILE_shift(sk)  \

  3440.   ((const SRTP_PROTECTION_PROFILE *)sk_shift( \

  3441.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3442. 

  3443. #define sk_SRTP_PROTECTION_PROFILE_push(sk, p)                             \

  3444.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3445.           CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

  3446. 

  3447. #define sk_SRTP_PROTECTION_PROFILE_pop(sk)  \

  3448.   ((const SRTP_PROTECTION_PROFILE *)sk_pop( \

  3449.       CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3450. 

  3451. #define sk_SRTP_PROTECTION_PROFILE_dup(sk)      \

  3452.   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup( \

  3453.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

  3454. 

  3455. #define sk_SRTP_PROTECTION_PROFILE_sort(sk) \

  3456.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3457. 

  3458. #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \

  3459.   sk_is_sorted(                                  \

  3460.       CHECKED_CAST(_STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

  3461. 

  3462. #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp)               \

  3463.   ((int (*)(const SRTP_PROTECTION_PROFILE **a,                          \

  3464.             const SRTP_PROTECTION_PROFILE **b))                         \

  3465.    sk_set_cmp_func(                                                     \

  3466.        CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \

  3467.        CHECKED_CAST(stack_cmp_func,                                     \

  3468.                     int (*)(const SRTP_PROTECTION_PROFILE **a,          \

  3469.                             const SRTP_PROTECTION_PROFILE **b),         \

  3470.                     comp)))

  3471. 

  3472. 

  3473. /* SSL_CIPHER */

  3474. #define sk_SSL_CIPHER_new(comp)                 \

  3475.   ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \

  3476.       stack_cmp_func,                           \

  3477.       int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp)))

  3478. 

  3479. #define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null())

  3480. 

  3481. #define sk_SSL_CIPHER_num(sk) \

  3482.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3483. 

  3484. #define sk_SSL_CIPHER_zero(sk) \

  3485.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));

  3486. 

  3487. #define sk_SSL_CIPHER_value(sk, i) \

  3488.   ((const SSL_CIPHER *)sk_value(   \

  3489.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))

  3490. 

  3491. #define sk_SSL_CIPHER_set(sk, i, p)                            \

  3492.   ((const SSL_CIPHER *)sk_set(                                 \

  3493.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \

  3494.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3495. 

  3496. #define sk_SSL_CIPHER_free(sk) \

  3497.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3498. 

  3499. #define sk_SSL_CIPHER_pop_free(sk, free_func)             \

  3500.   sk_pop_free(                                            \

  3501.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3502.       CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func))

  3503. 

  3504. #define sk_SSL_CIPHER_insert(sk, p, where)                      \

  3505.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3506.             CHECKED_CAST(void *, const SSL_CIPHER *, p), (where))

  3507. 

  3508. #define sk_SSL_CIPHER_delete(sk, where) \

  3509.   ((const SSL_CIPHER *)sk_delete(       \

  3510.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where)))

  3511. 

  3512. #define sk_SSL_CIPHER_delete_ptr(sk, p)                   \

  3513.   ((const SSL_CIPHER *)sk_delete_ptr(                     \

  3514.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3515.       CHECKED_CAST(void *, const SSL_CIPHER *, p)))

  3516. 

  3517. #define sk_SSL_CIPHER_find(sk, out_index, p)                               \

  3518.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \

  3519.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3520. 

  3521. #define sk_SSL_CIPHER_shift(sk)  \

  3522.   ((const SSL_CIPHER *)sk_shift( \

  3523.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3524. 

  3525. #define sk_SSL_CIPHER_push(sk, p)                             \

  3526.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \

  3527.           CHECKED_CAST(void *, const SSL_CIPHER *, p))

  3528. 

  3529. #define sk_SSL_CIPHER_pop(sk)  \

  3530.   ((const SSL_CIPHER *)sk_pop( \

  3531.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

  3532. 

  3533. #define sk_SSL_CIPHER_dup(sk)      \

  3534.   ((STACK_OF(SSL_CIPHER) *)sk_dup( \

  3535.       CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk)))

  3536. 

  3537. #define sk_SSL_CIPHER_sort(sk) \

  3538.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

  3539. 

  3540. #define sk_SSL_CIPHER_is_sorted(sk) \

  3541.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(SSL_CIPHER) *, sk))

  3542. 

  3543. #define sk_SSL_CIPHER_set_cmp_func(sk, comp)                             \

  3544.   ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \

  3545.       CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk),                \

  3546.       CHECKED_CAST(stack_cmp_func,                                       \

  3547.                    int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b),  \

  3548.                    comp)))

  3549. 

  3550. 

  3551. /* OPENSSL_STRING */

  3552. #define sk_OPENSSL_STRING_new(comp)                 \

  3553.   ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \

  3554.       stack_cmp_func,                               \

  3555.       int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))

  3556. 

  3557. #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())

  3558. 

  3559. #define sk_OPENSSL_STRING_num(sk) \

  3560.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3561. 

  3562. #define sk_OPENSSL_STRING_zero(sk) \

  3563.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));

  3564. 

  3565. #define sk_OPENSSL_STRING_value(sk, i) \

  3566.   ((OPENSSL_STRING)sk_value(           \

  3567.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk), (i)))

  3568. 

  3569. #define sk_OPENSSL_STRING_set(sk, i, p)                            \

  3570.   ((OPENSSL_STRING)sk_set(                                         \

  3571.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \

  3572.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3573. 

  3574. #define sk_OPENSSL_STRING_free(sk) \

  3575.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3576. 

  3577. #define sk_OPENSSL_STRING_pop_free(sk, free_func)             \

  3578.   sk_pop_free(                                                \

  3579.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3580.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))

  3581. 

  3582. #define sk_OPENSSL_STRING_insert(sk, p, where)                      \

  3583.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3584.             CHECKED_CAST(void *, OPENSSL_STRING, p), (where))

  3585. 

  3586. #define sk_OPENSSL_STRING_delete(sk, where) \

  3587.   ((OPENSSL_STRING)sk_delete(               \

  3588.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))

  3589. 

  3590. #define sk_OPENSSL_STRING_delete_ptr(sk, p)                   \

  3591.   ((OPENSSL_STRING)sk_delete_ptr(                             \

  3592.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3593.       CHECKED_CAST(void *, OPENSSL_STRING, p)))

  3594. 

  3595. #define sk_OPENSSL_STRING_find(sk, out_index, p)                               \

  3596.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \

  3597.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3598. 

  3599. #define sk_OPENSSL_STRING_shift(sk) \

  3600.   ((OPENSSL_STRING)sk_shift(        \

  3601.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3602. 

  3603. #define sk_OPENSSL_STRING_push(sk, p)                             \

  3604.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \

  3605.           CHECKED_CAST(void *, OPENSSL_STRING, p))

  3606. 

  3607. #define sk_OPENSSL_STRING_pop(sk) \

  3608.   ((OPENSSL_STRING)sk_pop(        \

  3609.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

  3610. 

  3611. #define sk_OPENSSL_STRING_dup(sk)      \

  3612.   ((STACK_OF(OPENSSL_STRING) *)sk_dup( \

  3613.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))

  3614. 

  3615. #define sk_OPENSSL_STRING_sort(sk) \

  3616.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

  3617. 

  3618. #define sk_OPENSSL_STRING_is_sorted(sk) \

  3619.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

  3620. 

  3621. #define sk_OPENSSL_STRING_set_cmp_func(sk, comp)                       \

  3622.   ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b))       \

  3623.    sk_set_cmp_func(                                                    \

  3624.        CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk),         \

  3625.        CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a,  \

  3626.                                             const OPENSSL_STRING **b), \

  3627.                     comp)))

  3628. 

  3629. 

  3630. /* OPENSSL_BLOCK */

  3631. #define sk_OPENSSL_BLOCK_new(comp)                                             \

  3632.   ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_CAST(                             \

  3633.       stack_cmp_func, int (*)(const OPENSSL_BLOCK *a, const OPENSSL_BLOCK *b), \

  3634.       comp)))

  3635. 

  3636. #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())

  3637. 

  3638. #define sk_OPENSSL_BLOCK_num(sk) \

  3639.   sk_num(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3640. 

  3641. #define sk_OPENSSL_BLOCK_zero(sk) \

  3642.   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk));

  3643. 

  3644. #define sk_OPENSSL_BLOCK_value(sk, i) \

  3645.   ((OPENSSL_BLOCK)sk_value(           \

  3646.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), (i)))

  3647. 

  3648. #define sk_OPENSSL_BLOCK_set(sk, i, p)                            \

  3649.   ((OPENSSL_BLOCK)sk_set(                                         \

  3650.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (i), \

  3651.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  3652. 

  3653. #define sk_OPENSSL_BLOCK_free(sk) \

  3654.   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3655. 

  3656. #define sk_OPENSSL_BLOCK_pop_free(sk, free_func)             \

  3657.   sk_pop_free(                                               \

  3658.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3659.       CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func))

  3660. 

  3661. #define sk_OPENSSL_BLOCK_insert(sk, p, where)                      \

  3662.   sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3663.             CHECKED_CAST(void *, OPENSSL_BLOCK, p), (where))

  3664. 

  3665. #define sk_OPENSSL_BLOCK_delete(sk, where) \

  3666.   ((OPENSSL_BLOCK)sk_delete(               \

  3667.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (where)))

  3668. 

  3669. #define sk_OPENSSL_BLOCK_delete_ptr(sk, p)                   \

  3670.   ((OPENSSL_BLOCK)sk_delete_ptr(                             \

  3671.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3672.       CHECKED_CAST(void *, OPENSSL_BLOCK, p)))

  3673. 

  3674. #define sk_OPENSSL_BLOCK_find(sk, out_index, p)                               \

  3675.   sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (out_index), \

  3676.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  3677. 

  3678. #define sk_OPENSSL_BLOCK_shift(sk) \

  3679.   ((OPENSSL_BLOCK)sk_shift(        \

  3680.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  3681. 

  3682. #define sk_OPENSSL_BLOCK_push(sk, p)                             \

  3683.   sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \

  3684.           CHECKED_CAST(void *, OPENSSL_BLOCK, p))

  3685. 

  3686. #define sk_OPENSSL_BLOCK_pop(sk) \

  3687.   ((OPENSSL_BLOCK)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)))

  3688. 

  3689. #define sk_OPENSSL_BLOCK_dup(sk)      \

  3690.   ((STACK_OF(OPENSSL_BLOCK) *)sk_dup( \

  3691.       CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)))

  3692. 

  3693. #define sk_OPENSSL_BLOCK_sort(sk) \

  3694.   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))

  3695. 

  3696. #define sk_OPENSSL_BLOCK_is_sorted(sk) \

  3697.   sk_is_sorted(CHECKED_CAST(_STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk))

  3698. 

  3699. #define sk_OPENSSL_BLOCK_set_cmp_func(sk, comp)                                \

  3700.   ((int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b))sk_set_cmp_func( \

  3701.       CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk),                   \

  3702.       CHECKED_CAST(stack_cmp_func,                                             \

  3703.                    int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b),  \

  3704.                    comp)))