stack_macros.h File Reference

Go to the source code of this file.

Macros
#define	sk_ACCESS_DESCRIPTION_new(comp)
#define	sk_ACCESS_DESCRIPTION_new_null()   ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new_null())
#define	sk_ACCESS_DESCRIPTION_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk))
#define	sk_ACCESS_DESCRIPTION_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk));
#define	sk_ACCESS_DESCRIPTION_value(sk, i)
#define	sk_ACCESS_DESCRIPTION_set(sk, i, p)
#define	sk_ACCESS_DESCRIPTION_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))
#define	sk_ACCESS_DESCRIPTION_pop_free(sk, free_func)
#define	sk_ACCESS_DESCRIPTION_insert(sk, p, where)
#define	sk_ACCESS_DESCRIPTION_delete(sk, where)
#define	sk_ACCESS_DESCRIPTION_delete_ptr(sk, p)
#define	sk_ACCESS_DESCRIPTION_find(sk, out_index, p)
#define	sk_ACCESS_DESCRIPTION_shift(sk)
#define	sk_ACCESS_DESCRIPTION_push(sk, p)
#define	sk_ACCESS_DESCRIPTION_pop(sk)
#define	sk_ACCESS_DESCRIPTION_dup(sk)
#define	sk_ACCESS_DESCRIPTION_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))
#define	sk_ACCESS_DESCRIPTION_is_sorted(sk)
#define	sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp)
#define	sk_ACCESS_DESCRIPTION_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_ADB_TABLE_new(comp)
#define	sk_ASN1_ADB_TABLE_new_null()   ((STACK_OF(ASN1_ADB_TABLE) *)sk_new_null())
#define	sk_ASN1_ADB_TABLE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))
#define	sk_ASN1_ADB_TABLE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk));
#define	sk_ASN1_ADB_TABLE_value(sk, i)
#define	sk_ASN1_ADB_TABLE_set(sk, i, p)
#define	sk_ASN1_ADB_TABLE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))
#define	sk_ASN1_ADB_TABLE_pop_free(sk, free_func)
#define	sk_ASN1_ADB_TABLE_insert(sk, p, where)
#define	sk_ASN1_ADB_TABLE_delete(sk, where)
#define	sk_ASN1_ADB_TABLE_delete_ptr(sk, p)
#define	sk_ASN1_ADB_TABLE_find(sk, out_index, p)
#define	sk_ASN1_ADB_TABLE_shift(sk)
#define	sk_ASN1_ADB_TABLE_push(sk, p)
#define	sk_ASN1_ADB_TABLE_pop(sk)
#define	sk_ASN1_ADB_TABLE_dup(sk)
#define	sk_ASN1_ADB_TABLE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))
#define	sk_ASN1_ADB_TABLE_is_sorted(sk)
#define	sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp)
#define	sk_ASN1_ADB_TABLE_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_GENERALSTRING_new(comp)
#define	sk_ASN1_GENERALSTRING_new_null()   ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())
#define	sk_ASN1_GENERALSTRING_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))
#define	sk_ASN1_GENERALSTRING_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk));
#define	sk_ASN1_GENERALSTRING_value(sk, i)
#define	sk_ASN1_GENERALSTRING_set(sk, i, p)
#define	sk_ASN1_GENERALSTRING_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))
#define	sk_ASN1_GENERALSTRING_pop_free(sk, free_func)
#define	sk_ASN1_GENERALSTRING_insert(sk, p, where)
#define	sk_ASN1_GENERALSTRING_delete(sk, where)
#define	sk_ASN1_GENERALSTRING_delete_ptr(sk, p)
#define	sk_ASN1_GENERALSTRING_find(sk, out_index, p)
#define	sk_ASN1_GENERALSTRING_shift(sk)
#define	sk_ASN1_GENERALSTRING_push(sk, p)
#define	sk_ASN1_GENERALSTRING_pop(sk)
#define	sk_ASN1_GENERALSTRING_dup(sk)
#define	sk_ASN1_GENERALSTRING_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))
#define	sk_ASN1_GENERALSTRING_is_sorted(sk)
#define	sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp)
#define	sk_ASN1_GENERALSTRING_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_INTEGER_new(comp)
#define	sk_ASN1_INTEGER_new_null()   ((STACK_OF(ASN1_INTEGER) *)sk_new_null())
#define	sk_ASN1_INTEGER_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk))
#define	sk_ASN1_INTEGER_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk));
#define	sk_ASN1_INTEGER_value(sk, i)
#define	sk_ASN1_INTEGER_set(sk, i, p)
#define	sk_ASN1_INTEGER_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))
#define	sk_ASN1_INTEGER_pop_free(sk, free_func)
#define	sk_ASN1_INTEGER_insert(sk, p, where)
#define	sk_ASN1_INTEGER_delete(sk, where)
#define	sk_ASN1_INTEGER_delete_ptr(sk, p)
#define	sk_ASN1_INTEGER_find(sk, out_index, p)
#define	sk_ASN1_INTEGER_shift(sk)
#define	sk_ASN1_INTEGER_push(sk, p)
#define	sk_ASN1_INTEGER_pop(sk)   ((ASN1_INTEGER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))
#define	sk_ASN1_INTEGER_dup(sk)
#define	sk_ASN1_INTEGER_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))
#define	sk_ASN1_INTEGER_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk))
#define	sk_ASN1_INTEGER_set_cmp_func(sk, comp)
#define	sk_ASN1_INTEGER_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_OBJECT_new(comp)
#define	sk_ASN1_OBJECT_new_null()   ((STACK_OF(ASN1_OBJECT) *)sk_new_null())
#define	sk_ASN1_OBJECT_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk))
#define	sk_ASN1_OBJECT_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk));
#define	sk_ASN1_OBJECT_value(sk, i)
#define	sk_ASN1_OBJECT_set(sk, i, p)
#define	sk_ASN1_OBJECT_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))
#define	sk_ASN1_OBJECT_pop_free(sk, free_func)
#define	sk_ASN1_OBJECT_insert(sk, p, where)
#define	sk_ASN1_OBJECT_delete(sk, where)
#define	sk_ASN1_OBJECT_delete_ptr(sk, p)
#define	sk_ASN1_OBJECT_find(sk, out_index, p)
#define	sk_ASN1_OBJECT_shift(sk)   ((ASN1_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))
#define	sk_ASN1_OBJECT_push(sk, p)
#define	sk_ASN1_OBJECT_pop(sk)   ((ASN1_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)))
#define	sk_ASN1_OBJECT_dup(sk)
#define	sk_ASN1_OBJECT_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))
#define	sk_ASN1_OBJECT_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk))
#define	sk_ASN1_OBJECT_set_cmp_func(sk, comp)
#define	sk_ASN1_OBJECT_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_STRING_TABLE_new(comp)
#define	sk_ASN1_STRING_TABLE_new_null()   ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())
#define	sk_ASN1_STRING_TABLE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))
#define	sk_ASN1_STRING_TABLE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk));
#define	sk_ASN1_STRING_TABLE_value(sk, i)
#define	sk_ASN1_STRING_TABLE_set(sk, i, p)
#define	sk_ASN1_STRING_TABLE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))
#define	sk_ASN1_STRING_TABLE_pop_free(sk, free_func)
#define	sk_ASN1_STRING_TABLE_insert(sk, p, where)
#define	sk_ASN1_STRING_TABLE_delete(sk, where)
#define	sk_ASN1_STRING_TABLE_delete_ptr(sk, p)
#define	sk_ASN1_STRING_TABLE_find(sk, out_index, p)
#define	sk_ASN1_STRING_TABLE_shift(sk)
#define	sk_ASN1_STRING_TABLE_push(sk, p)
#define	sk_ASN1_STRING_TABLE_pop(sk)
#define	sk_ASN1_STRING_TABLE_dup(sk)
#define	sk_ASN1_STRING_TABLE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))
#define	sk_ASN1_STRING_TABLE_is_sorted(sk)
#define	sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp)
#define	sk_ASN1_STRING_TABLE_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_TYPE_new(comp)
#define	sk_ASN1_TYPE_new_null()   ((STACK_OF(ASN1_TYPE) *)sk_new_null())
#define	sk_ASN1_TYPE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk))
#define	sk_ASN1_TYPE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk));
#define	sk_ASN1_TYPE_value(sk, i)
#define	sk_ASN1_TYPE_set(sk, i, p)
#define	sk_ASN1_TYPE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))
#define	sk_ASN1_TYPE_pop_free(sk, free_func)
#define	sk_ASN1_TYPE_insert(sk, p, where)
#define	sk_ASN1_TYPE_delete(sk, where)
#define	sk_ASN1_TYPE_delete_ptr(sk, p)
#define	sk_ASN1_TYPE_find(sk, out_index, p)
#define	sk_ASN1_TYPE_shift(sk)   ((ASN1_TYPE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))
#define	sk_ASN1_TYPE_push(sk, p)
#define	sk_ASN1_TYPE_pop(sk)   ((ASN1_TYPE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)))
#define	sk_ASN1_TYPE_dup(sk)
#define	sk_ASN1_TYPE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))
#define	sk_ASN1_TYPE_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk))
#define	sk_ASN1_TYPE_set_cmp_func(sk, comp)
#define	sk_ASN1_TYPE_deep_copy(sk, copy_func, free_func)
#define	sk_ASN1_VALUE_new(comp)
#define	sk_ASN1_VALUE_new_null()   ((STACK_OF(ASN1_VALUE) *)sk_new_null())
#define	sk_ASN1_VALUE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk))
#define	sk_ASN1_VALUE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk));
#define	sk_ASN1_VALUE_value(sk, i)
#define	sk_ASN1_VALUE_set(sk, i, p)
#define	sk_ASN1_VALUE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))
#define	sk_ASN1_VALUE_pop_free(sk, free_func)
#define	sk_ASN1_VALUE_insert(sk, p, where)
#define	sk_ASN1_VALUE_delete(sk, where)
#define	sk_ASN1_VALUE_delete_ptr(sk, p)
#define	sk_ASN1_VALUE_find(sk, out_index, p)
#define	sk_ASN1_VALUE_shift(sk)   ((ASN1_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))
#define	sk_ASN1_VALUE_push(sk, p)
#define	sk_ASN1_VALUE_pop(sk)   ((ASN1_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)))
#define	sk_ASN1_VALUE_dup(sk)
#define	sk_ASN1_VALUE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))
#define	sk_ASN1_VALUE_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk))
#define	sk_ASN1_VALUE_set_cmp_func(sk, comp)
#define	sk_ASN1_VALUE_deep_copy(sk, copy_func, free_func)
#define	sk_BIO_new(comp)
#define	sk_BIO_new_null()   ((STACK_OF(BIO) *)sk_new_null())
#define	sk_BIO_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk))
#define	sk_BIO_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk));
#define	sk_BIO_value(sk, i)
#define	sk_BIO_set(sk, i, p)
#define	sk_BIO_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))
#define	sk_BIO_pop_free(sk, free_func)
#define	sk_BIO_insert(sk, p, where)
#define	sk_BIO_delete(sk, where)   ((BIO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (where)))
#define	sk_BIO_delete_ptr(sk, p)
#define	sk_BIO_find(sk, out_index, p)
#define	sk_BIO_shift(sk)   ((BIO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))
#define	sk_BIO_push(sk, p)
#define	sk_BIO_pop(sk)   ((BIO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)))
#define	sk_BIO_dup(sk)
#define	sk_BIO_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))
#define	sk_BIO_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk))
#define	sk_BIO_set_cmp_func(sk, comp)
#define	sk_BIO_deep_copy(sk, copy_func, free_func)
#define	sk_BY_DIR_ENTRY_new(comp)
#define	sk_BY_DIR_ENTRY_new_null()   ((STACK_OF(BY_DIR_ENTRY) *)sk_new_null())
#define	sk_BY_DIR_ENTRY_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))
#define	sk_BY_DIR_ENTRY_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk));
#define	sk_BY_DIR_ENTRY_value(sk, i)
#define	sk_BY_DIR_ENTRY_set(sk, i, p)
#define	sk_BY_DIR_ENTRY_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))
#define	sk_BY_DIR_ENTRY_pop_free(sk, free_func)
#define	sk_BY_DIR_ENTRY_insert(sk, p, where)
#define	sk_BY_DIR_ENTRY_delete(sk, where)
#define	sk_BY_DIR_ENTRY_delete_ptr(sk, p)
#define	sk_BY_DIR_ENTRY_find(sk, out_index, p)
#define	sk_BY_DIR_ENTRY_shift(sk)
#define	sk_BY_DIR_ENTRY_push(sk, p)
#define	sk_BY_DIR_ENTRY_pop(sk)   ((BY_DIR_ENTRY *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))
#define	sk_BY_DIR_ENTRY_dup(sk)
#define	sk_BY_DIR_ENTRY_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))
#define	sk_BY_DIR_ENTRY_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))
#define	sk_BY_DIR_ENTRY_set_cmp_func(sk, comp)
#define	sk_BY_DIR_ENTRY_deep_copy(sk, copy_func, free_func)
#define	sk_BY_DIR_HASH_new(comp)
#define	sk_BY_DIR_HASH_new_null()   ((STACK_OF(BY_DIR_HASH) *)sk_new_null())
#define	sk_BY_DIR_HASH_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk))
#define	sk_BY_DIR_HASH_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk));
#define	sk_BY_DIR_HASH_value(sk, i)
#define	sk_BY_DIR_HASH_set(sk, i, p)
#define	sk_BY_DIR_HASH_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))
#define	sk_BY_DIR_HASH_pop_free(sk, free_func)
#define	sk_BY_DIR_HASH_insert(sk, p, where)
#define	sk_BY_DIR_HASH_delete(sk, where)
#define	sk_BY_DIR_HASH_delete_ptr(sk, p)
#define	sk_BY_DIR_HASH_find(sk, out_index, p)
#define	sk_BY_DIR_HASH_shift(sk)   ((BY_DIR_HASH *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))
#define	sk_BY_DIR_HASH_push(sk, p)
#define	sk_BY_DIR_HASH_pop(sk)   ((BY_DIR_HASH *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)))
#define	sk_BY_DIR_HASH_dup(sk)
#define	sk_BY_DIR_HASH_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))
#define	sk_BY_DIR_HASH_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk))
#define	sk_BY_DIR_HASH_set_cmp_func(sk, comp)
#define	sk_BY_DIR_HASH_deep_copy(sk, copy_func, free_func)
#define	sk_CONF_VALUE_new(comp)
#define	sk_CONF_VALUE_new_null()   ((STACK_OF(CONF_VALUE) *)sk_new_null())
#define	sk_CONF_VALUE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk))
#define	sk_CONF_VALUE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk));
#define	sk_CONF_VALUE_value(sk, i)
#define	sk_CONF_VALUE_set(sk, i, p)
#define	sk_CONF_VALUE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))
#define	sk_CONF_VALUE_pop_free(sk, free_func)
#define	sk_CONF_VALUE_insert(sk, p, where)
#define	sk_CONF_VALUE_delete(sk, where)
#define	sk_CONF_VALUE_delete_ptr(sk, p)
#define	sk_CONF_VALUE_find(sk, out_index, p)
#define	sk_CONF_VALUE_shift(sk)   ((CONF_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))
#define	sk_CONF_VALUE_push(sk, p)
#define	sk_CONF_VALUE_pop(sk)   ((CONF_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)))
#define	sk_CONF_VALUE_dup(sk)
#define	sk_CONF_VALUE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))
#define	sk_CONF_VALUE_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk))
#define	sk_CONF_VALUE_set_cmp_func(sk, comp)
#define	sk_CONF_VALUE_deep_copy(sk, copy_func, free_func)
#define	sk_CRYPTO_EX_DATA_FUNCS_new(comp)
#define	sk_CRYPTO_EX_DATA_FUNCS_new_null()   ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())
#define	sk_CRYPTO_EX_DATA_FUNCS_num(sk)
#define	sk_CRYPTO_EX_DATA_FUNCS_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk));
#define	sk_CRYPTO_EX_DATA_FUNCS_value(sk, i)
#define	sk_CRYPTO_EX_DATA_FUNCS_set(sk, i, p)
#define	sk_CRYPTO_EX_DATA_FUNCS_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
#define	sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func)
#define	sk_CRYPTO_EX_DATA_FUNCS_insert(sk, p, where)
#define	sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where)
#define	sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p)
#define	sk_CRYPTO_EX_DATA_FUNCS_find(sk, out_index, p)
#define	sk_CRYPTO_EX_DATA_FUNCS_shift(sk)
#define	sk_CRYPTO_EX_DATA_FUNCS_push(sk, p)
#define	sk_CRYPTO_EX_DATA_FUNCS_pop(sk)
#define	sk_CRYPTO_EX_DATA_FUNCS_dup(sk)
#define	sk_CRYPTO_EX_DATA_FUNCS_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))
#define	sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk)
#define	sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp)
#define	sk_CRYPTO_EX_DATA_FUNCS_deep_copy(sk, copy_func, free_func)
#define	sk_DIST_POINT_new(comp)
#define	sk_DIST_POINT_new_null()   ((STACK_OF(DIST_POINT) *)sk_new_null())
#define	sk_DIST_POINT_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk))
#define	sk_DIST_POINT_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk));
#define	sk_DIST_POINT_value(sk, i)
#define	sk_DIST_POINT_set(sk, i, p)
#define	sk_DIST_POINT_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))
#define	sk_DIST_POINT_pop_free(sk, free_func)
#define	sk_DIST_POINT_insert(sk, p, where)
#define	sk_DIST_POINT_delete(sk, where)
#define	sk_DIST_POINT_delete_ptr(sk, p)
#define	sk_DIST_POINT_find(sk, out_index, p)
#define	sk_DIST_POINT_shift(sk)   ((DIST_POINT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))
#define	sk_DIST_POINT_push(sk, p)
#define	sk_DIST_POINT_pop(sk)   ((DIST_POINT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)))
#define	sk_DIST_POINT_dup(sk)
#define	sk_DIST_POINT_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))
#define	sk_DIST_POINT_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk))
#define	sk_DIST_POINT_set_cmp_func(sk, comp)
#define	sk_DIST_POINT_deep_copy(sk, copy_func, free_func)
#define	sk_GENERAL_NAME_new(comp)
#define	sk_GENERAL_NAME_new_null()   ((STACK_OF(GENERAL_NAME) *)sk_new_null())
#define	sk_GENERAL_NAME_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk))
#define	sk_GENERAL_NAME_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk));
#define	sk_GENERAL_NAME_value(sk, i)
#define	sk_GENERAL_NAME_set(sk, i, p)
#define	sk_GENERAL_NAME_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))
#define	sk_GENERAL_NAME_pop_free(sk, free_func)
#define	sk_GENERAL_NAME_insert(sk, p, where)
#define	sk_GENERAL_NAME_delete(sk, where)
#define	sk_GENERAL_NAME_delete_ptr(sk, p)
#define	sk_GENERAL_NAME_find(sk, out_index, p)
#define	sk_GENERAL_NAME_shift(sk)
#define	sk_GENERAL_NAME_push(sk, p)
#define	sk_GENERAL_NAME_pop(sk)   ((GENERAL_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))
#define	sk_GENERAL_NAME_dup(sk)
#define	sk_GENERAL_NAME_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))
#define	sk_GENERAL_NAME_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk))
#define	sk_GENERAL_NAME_set_cmp_func(sk, comp)
#define	sk_GENERAL_NAME_deep_copy(sk, copy_func, free_func)
#define	sk_GENERAL_NAMES_new(comp)
#define	sk_GENERAL_NAMES_new_null()   ((STACK_OF(GENERAL_NAMES) *)sk_new_null())
#define	sk_GENERAL_NAMES_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk))
#define	sk_GENERAL_NAMES_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk));
#define	sk_GENERAL_NAMES_value(sk, i)
#define	sk_GENERAL_NAMES_set(sk, i, p)
#define	sk_GENERAL_NAMES_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))
#define	sk_GENERAL_NAMES_pop_free(sk, free_func)
#define	sk_GENERAL_NAMES_insert(sk, p, where)
#define	sk_GENERAL_NAMES_delete(sk, where)
#define	sk_GENERAL_NAMES_delete_ptr(sk, p)
#define	sk_GENERAL_NAMES_find(sk, out_index, p)
#define	sk_GENERAL_NAMES_shift(sk)
#define	sk_GENERAL_NAMES_push(sk, p)
#define	sk_GENERAL_NAMES_pop(sk)
#define	sk_GENERAL_NAMES_dup(sk)
#define	sk_GENERAL_NAMES_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))
#define	sk_GENERAL_NAMES_is_sorted(sk)
#define	sk_GENERAL_NAMES_set_cmp_func(sk, comp)
#define	sk_GENERAL_NAMES_deep_copy(sk, copy_func, free_func)
#define	sk_GENERAL_SUBTREE_new(comp)
#define	sk_GENERAL_SUBTREE_new_null()   ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())
#define	sk_GENERAL_SUBTREE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))
#define	sk_GENERAL_SUBTREE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk));
#define	sk_GENERAL_SUBTREE_value(sk, i)
#define	sk_GENERAL_SUBTREE_set(sk, i, p)
#define	sk_GENERAL_SUBTREE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))
#define	sk_GENERAL_SUBTREE_pop_free(sk, free_func)
#define	sk_GENERAL_SUBTREE_insert(sk, p, where)
#define	sk_GENERAL_SUBTREE_delete(sk, where)
#define	sk_GENERAL_SUBTREE_delete_ptr(sk, p)
#define	sk_GENERAL_SUBTREE_find(sk, out_index, p)
#define	sk_GENERAL_SUBTREE_shift(sk)
#define	sk_GENERAL_SUBTREE_push(sk, p)
#define	sk_GENERAL_SUBTREE_pop(sk)
#define	sk_GENERAL_SUBTREE_dup(sk)
#define	sk_GENERAL_SUBTREE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))
#define	sk_GENERAL_SUBTREE_is_sorted(sk)
#define	sk_GENERAL_SUBTREE_set_cmp_func(sk, comp)
#define	sk_GENERAL_SUBTREE_deep_copy(sk, copy_func, free_func)
#define	sk_POLICYINFO_new(comp)
#define	sk_POLICYINFO_new_null()   ((STACK_OF(POLICYINFO) *)sk_new_null())
#define	sk_POLICYINFO_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk))
#define	sk_POLICYINFO_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk));
#define	sk_POLICYINFO_value(sk, i)
#define	sk_POLICYINFO_set(sk, i, p)
#define	sk_POLICYINFO_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))
#define	sk_POLICYINFO_pop_free(sk, free_func)
#define	sk_POLICYINFO_insert(sk, p, where)
#define	sk_POLICYINFO_delete(sk, where)
#define	sk_POLICYINFO_delete_ptr(sk, p)
#define	sk_POLICYINFO_find(sk, out_index, p)
#define	sk_POLICYINFO_shift(sk)   ((POLICYINFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))
#define	sk_POLICYINFO_push(sk, p)
#define	sk_POLICYINFO_pop(sk)   ((POLICYINFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)))
#define	sk_POLICYINFO_dup(sk)
#define	sk_POLICYINFO_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))
#define	sk_POLICYINFO_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk))
#define	sk_POLICYINFO_set_cmp_func(sk, comp)
#define	sk_POLICYINFO_deep_copy(sk, copy_func, free_func)
#define	sk_POLICYQUALINFO_new(comp)
#define	sk_POLICYQUALINFO_new_null()   ((STACK_OF(POLICYQUALINFO) *)sk_new_null())
#define	sk_POLICYQUALINFO_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk))
#define	sk_POLICYQUALINFO_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk));
#define	sk_POLICYQUALINFO_value(sk, i)
#define	sk_POLICYQUALINFO_set(sk, i, p)
#define	sk_POLICYQUALINFO_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))
#define	sk_POLICYQUALINFO_pop_free(sk, free_func)
#define	sk_POLICYQUALINFO_insert(sk, p, where)
#define	sk_POLICYQUALINFO_delete(sk, where)
#define	sk_POLICYQUALINFO_delete_ptr(sk, p)
#define	sk_POLICYQUALINFO_find(sk, out_index, p)
#define	sk_POLICYQUALINFO_shift(sk)
#define	sk_POLICYQUALINFO_push(sk, p)
#define	sk_POLICYQUALINFO_pop(sk)
#define	sk_POLICYQUALINFO_dup(sk)
#define	sk_POLICYQUALINFO_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))
#define	sk_POLICYQUALINFO_is_sorted(sk)
#define	sk_POLICYQUALINFO_set_cmp_func(sk, comp)
#define	sk_POLICYQUALINFO_deep_copy(sk, copy_func, free_func)
#define	sk_POLICY_MAPPING_new(comp)
#define	sk_POLICY_MAPPING_new_null()   ((STACK_OF(POLICY_MAPPING) *)sk_new_null())
#define	sk_POLICY_MAPPING_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk))
#define	sk_POLICY_MAPPING_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk));
#define	sk_POLICY_MAPPING_value(sk, i)
#define	sk_POLICY_MAPPING_set(sk, i, p)
#define	sk_POLICY_MAPPING_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))
#define	sk_POLICY_MAPPING_pop_free(sk, free_func)
#define	sk_POLICY_MAPPING_insert(sk, p, where)
#define	sk_POLICY_MAPPING_delete(sk, where)
#define	sk_POLICY_MAPPING_delete_ptr(sk, p)
#define	sk_POLICY_MAPPING_find(sk, out_index, p)
#define	sk_POLICY_MAPPING_shift(sk)
#define	sk_POLICY_MAPPING_push(sk, p)
#define	sk_POLICY_MAPPING_pop(sk)
#define	sk_POLICY_MAPPING_dup(sk)
#define	sk_POLICY_MAPPING_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))
#define	sk_POLICY_MAPPING_is_sorted(sk)
#define	sk_POLICY_MAPPING_set_cmp_func(sk, comp)
#define	sk_POLICY_MAPPING_deep_copy(sk, copy_func, free_func)
#define	sk_RSA_additional_prime_new(comp)
#define	sk_RSA_additional_prime_new_null()   ((STACK_OF(RSA_additional_prime) *)sk_new_null())
#define	sk_RSA_additional_prime_num(sk)
#define	sk_RSA_additional_prime_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk));
#define	sk_RSA_additional_prime_value(sk, i)
#define	sk_RSA_additional_prime_set(sk, i, p)
#define	sk_RSA_additional_prime_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))
#define	sk_RSA_additional_prime_pop_free(sk, free_func)
#define	sk_RSA_additional_prime_insert(sk, p, where)
#define	sk_RSA_additional_prime_delete(sk, where)
#define	sk_RSA_additional_prime_delete_ptr(sk, p)
#define	sk_RSA_additional_prime_find(sk, out_index, p)
#define	sk_RSA_additional_prime_shift(sk)
#define	sk_RSA_additional_prime_push(sk, p)
#define	sk_RSA_additional_prime_pop(sk)
#define	sk_RSA_additional_prime_dup(sk)
#define	sk_RSA_additional_prime_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))
#define	sk_RSA_additional_prime_is_sorted(sk)
#define	sk_RSA_additional_prime_set_cmp_func(sk, comp)
#define	sk_RSA_additional_prime_deep_copy(sk, copy_func, free_func)
#define	sk_SSL_COMP_new(comp)
#define	sk_SSL_COMP_new_null()   ((STACK_OF(SSL_COMP) *)sk_new_null())
#define	sk_SSL_COMP_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk))
#define	sk_SSL_COMP_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk));
#define	sk_SSL_COMP_value(sk, i)
#define	sk_SSL_COMP_set(sk, i, p)
#define	sk_SSL_COMP_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))
#define	sk_SSL_COMP_pop_free(sk, free_func)
#define	sk_SSL_COMP_insert(sk, p, where)
#define	sk_SSL_COMP_delete(sk, where)
#define	sk_SSL_COMP_delete_ptr(sk, p)
#define	sk_SSL_COMP_find(sk, out_index, p)
#define	sk_SSL_COMP_shift(sk)   ((SSL_COMP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))
#define	sk_SSL_COMP_push(sk, p)
#define	sk_SSL_COMP_pop(sk)   ((SSL_COMP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)))
#define	sk_SSL_COMP_dup(sk)
#define	sk_SSL_COMP_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))
#define	sk_SSL_COMP_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk))
#define	sk_SSL_COMP_set_cmp_func(sk, comp)
#define	sk_SSL_COMP_deep_copy(sk, copy_func, free_func)
#define	sk_SSL_CUSTOM_EXTENSION_new(comp)
#define	sk_SSL_CUSTOM_EXTENSION_new_null()   ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null())
#define	sk_SSL_CUSTOM_EXTENSION_num(sk)
#define	sk_SSL_CUSTOM_EXTENSION_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk));
#define	sk_SSL_CUSTOM_EXTENSION_value(sk, i)
#define	sk_SSL_CUSTOM_EXTENSION_set(sk, i, p)
#define	sk_SSL_CUSTOM_EXTENSION_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))
#define	sk_SSL_CUSTOM_EXTENSION_pop_free(sk, free_func)
#define	sk_SSL_CUSTOM_EXTENSION_insert(sk, p, where)
#define	sk_SSL_CUSTOM_EXTENSION_delete(sk, where)
#define	sk_SSL_CUSTOM_EXTENSION_delete_ptr(sk, p)
#define	sk_SSL_CUSTOM_EXTENSION_find(sk, out_index, p)
#define	sk_SSL_CUSTOM_EXTENSION_shift(sk)
#define	sk_SSL_CUSTOM_EXTENSION_push(sk, p)
#define	sk_SSL_CUSTOM_EXTENSION_pop(sk)
#define	sk_SSL_CUSTOM_EXTENSION_dup(sk)
#define	sk_SSL_CUSTOM_EXTENSION_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))
#define	sk_SSL_CUSTOM_EXTENSION_is_sorted(sk)
#define	sk_SSL_CUSTOM_EXTENSION_set_cmp_func(sk, comp)
#define	sk_SSL_CUSTOM_EXTENSION_deep_copy(sk, copy_func, free_func)
#define	sk_STACK_OF_X509_NAME_ENTRY_new(comp)
#define	sk_STACK_OF_X509_NAME_ENTRY_new_null()   ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())
#define	sk_STACK_OF_X509_NAME_ENTRY_num(sk)
#define	sk_STACK_OF_X509_NAME_ENTRY_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk));
#define	sk_STACK_OF_X509_NAME_ENTRY_value(sk, i)
#define	sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p)
#define	sk_STACK_OF_X509_NAME_ENTRY_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
#define	sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func)
#define	sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where)
#define	sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where)
#define	sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p)
#define	sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p)
#define	sk_STACK_OF_X509_NAME_ENTRY_shift(sk)
#define	sk_STACK_OF_X509_NAME_ENTRY_push(sk, p)
#define	sk_STACK_OF_X509_NAME_ENTRY_pop(sk)
#define	sk_STACK_OF_X509_NAME_ENTRY_dup(sk)
#define	sk_STACK_OF_X509_NAME_ENTRY_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))
#define	sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk)
#define	sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp)
#define	sk_STACK_OF_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)
#define	sk_SXNETID_new(comp)
#define	sk_SXNETID_new_null()   ((STACK_OF(SXNETID) *)sk_new_null())
#define	sk_SXNETID_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))
#define	sk_SXNETID_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk));
#define	sk_SXNETID_value(sk, i)
#define	sk_SXNETID_set(sk, i, p)
#define	sk_SXNETID_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))
#define	sk_SXNETID_pop_free(sk, free_func)
#define	sk_SXNETID_insert(sk, p, where)
#define	sk_SXNETID_delete(sk, where)
#define	sk_SXNETID_delete_ptr(sk, p)
#define	sk_SXNETID_find(sk, out_index, p)
#define	sk_SXNETID_shift(sk)   ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))
#define	sk_SXNETID_push(sk, p)
#define	sk_SXNETID_pop(sk)   ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)))
#define	sk_SXNETID_dup(sk)
#define	sk_SXNETID_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))
#define	sk_SXNETID_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))
#define	sk_SXNETID_set_cmp_func(sk, comp)
#define	sk_SXNETID_deep_copy(sk, copy_func, free_func)
#define	sk_X509_new(comp)
#define	sk_X509_new_null()   ((STACK_OF(X509) *)sk_new_null())
#define	sk_X509_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))
#define	sk_X509_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));
#define	sk_X509_value(sk, i)
#define	sk_X509_set(sk, i, p)
#define	sk_X509_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))
#define	sk_X509_pop_free(sk, free_func)
#define	sk_X509_insert(sk, p, where)
#define	sk_X509_delete(sk, where)   ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))
#define	sk_X509_delete_ptr(sk, p)
#define	sk_X509_find(sk, out_index, p)
#define	sk_X509_shift(sk)   ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))
#define	sk_X509_push(sk, p)
#define	sk_X509_pop(sk)   ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)))
#define	sk_X509_dup(sk)
#define	sk_X509_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))
#define	sk_X509_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))
#define	sk_X509_set_cmp_func(sk, comp)
#define	sk_X509_deep_copy(sk, copy_func, free_func)
#define	sk_X509V3_EXT_METHOD_new(comp)
#define	sk_X509V3_EXT_METHOD_new_null()   ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())
#define	sk_X509V3_EXT_METHOD_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))
#define	sk_X509V3_EXT_METHOD_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk));
#define	sk_X509V3_EXT_METHOD_value(sk, i)
#define	sk_X509V3_EXT_METHOD_set(sk, i, p)
#define	sk_X509V3_EXT_METHOD_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))
#define	sk_X509V3_EXT_METHOD_pop_free(sk, free_func)
#define	sk_X509V3_EXT_METHOD_insert(sk, p, where)
#define	sk_X509V3_EXT_METHOD_delete(sk, where)
#define	sk_X509V3_EXT_METHOD_delete_ptr(sk, p)
#define	sk_X509V3_EXT_METHOD_find(sk, out_index, p)
#define	sk_X509V3_EXT_METHOD_shift(sk)
#define	sk_X509V3_EXT_METHOD_push(sk, p)
#define	sk_X509V3_EXT_METHOD_pop(sk)
#define	sk_X509V3_EXT_METHOD_dup(sk)
#define	sk_X509V3_EXT_METHOD_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))
#define	sk_X509V3_EXT_METHOD_is_sorted(sk)
#define	sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp)
#define	sk_X509V3_EXT_METHOD_deep_copy(sk, copy_func, free_func)
#define	sk_X509_ALGOR_new(comp)
#define	sk_X509_ALGOR_new_null()   ((STACK_OF(X509_ALGOR) *)sk_new_null())
#define	sk_X509_ALGOR_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))
#define	sk_X509_ALGOR_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk));
#define	sk_X509_ALGOR_value(sk, i)
#define	sk_X509_ALGOR_set(sk, i, p)
#define	sk_X509_ALGOR_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))
#define	sk_X509_ALGOR_pop_free(sk, free_func)
#define	sk_X509_ALGOR_insert(sk, p, where)
#define	sk_X509_ALGOR_delete(sk, where)
#define	sk_X509_ALGOR_delete_ptr(sk, p)
#define	sk_X509_ALGOR_find(sk, out_index, p)
#define	sk_X509_ALGOR_shift(sk)   ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))
#define	sk_X509_ALGOR_push(sk, p)
#define	sk_X509_ALGOR_pop(sk)   ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)))
#define	sk_X509_ALGOR_dup(sk)
#define	sk_X509_ALGOR_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))
#define	sk_X509_ALGOR_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))
#define	sk_X509_ALGOR_set_cmp_func(sk, comp)
#define	sk_X509_ALGOR_deep_copy(sk, copy_func, free_func)
#define	sk_X509_ATTRIBUTE_new(comp)
#define	sk_X509_ATTRIBUTE_new_null()   ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())
#define	sk_X509_ATTRIBUTE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))
#define	sk_X509_ATTRIBUTE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk));
#define	sk_X509_ATTRIBUTE_value(sk, i)
#define	sk_X509_ATTRIBUTE_set(sk, i, p)
#define	sk_X509_ATTRIBUTE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))
#define	sk_X509_ATTRIBUTE_pop_free(sk, free_func)
#define	sk_X509_ATTRIBUTE_insert(sk, p, where)
#define	sk_X509_ATTRIBUTE_delete(sk, where)
#define	sk_X509_ATTRIBUTE_delete_ptr(sk, p)
#define	sk_X509_ATTRIBUTE_find(sk, out_index, p)
#define	sk_X509_ATTRIBUTE_shift(sk)
#define	sk_X509_ATTRIBUTE_push(sk, p)
#define	sk_X509_ATTRIBUTE_pop(sk)
#define	sk_X509_ATTRIBUTE_dup(sk)
#define	sk_X509_ATTRIBUTE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))
#define	sk_X509_ATTRIBUTE_is_sorted(sk)
#define	sk_X509_ATTRIBUTE_set_cmp_func(sk, comp)
#define	sk_X509_ATTRIBUTE_deep_copy(sk, copy_func, free_func)
#define	sk_X509_CRL_new(comp)
#define	sk_X509_CRL_new_null()   ((STACK_OF(X509_CRL) *)sk_new_null())
#define	sk_X509_CRL_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))
#define	sk_X509_CRL_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk));
#define	sk_X509_CRL_value(sk, i)
#define	sk_X509_CRL_set(sk, i, p)
#define	sk_X509_CRL_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))
#define	sk_X509_CRL_pop_free(sk, free_func)
#define	sk_X509_CRL_insert(sk, p, where)
#define	sk_X509_CRL_delete(sk, where)
#define	sk_X509_CRL_delete_ptr(sk, p)
#define	sk_X509_CRL_find(sk, out_index, p)
#define	sk_X509_CRL_shift(sk)   ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))
#define	sk_X509_CRL_push(sk, p)
#define	sk_X509_CRL_pop(sk)   ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)))
#define	sk_X509_CRL_dup(sk)
#define	sk_X509_CRL_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))
#define	sk_X509_CRL_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))
#define	sk_X509_CRL_set_cmp_func(sk, comp)
#define	sk_X509_CRL_deep_copy(sk, copy_func, free_func)
#define	sk_X509_EXTENSION_new(comp)
#define	sk_X509_EXTENSION_new_null()   ((STACK_OF(X509_EXTENSION) *)sk_new_null())
#define	sk_X509_EXTENSION_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))
#define	sk_X509_EXTENSION_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk));
#define	sk_X509_EXTENSION_value(sk, i)
#define	sk_X509_EXTENSION_set(sk, i, p)
#define	sk_X509_EXTENSION_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))
#define	sk_X509_EXTENSION_pop_free(sk, free_func)
#define	sk_X509_EXTENSION_insert(sk, p, where)
#define	sk_X509_EXTENSION_delete(sk, where)
#define	sk_X509_EXTENSION_delete_ptr(sk, p)
#define	sk_X509_EXTENSION_find(sk, out_index, p)
#define	sk_X509_EXTENSION_shift(sk)
#define	sk_X509_EXTENSION_push(sk, p)
#define	sk_X509_EXTENSION_pop(sk)
#define	sk_X509_EXTENSION_dup(sk)
#define	sk_X509_EXTENSION_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))
#define	sk_X509_EXTENSION_is_sorted(sk)
#define	sk_X509_EXTENSION_set_cmp_func(sk, comp)
#define	sk_X509_EXTENSION_deep_copy(sk, copy_func, free_func)
#define	sk_X509_INFO_new(comp)
#define	sk_X509_INFO_new_null()   ((STACK_OF(X509_INFO) *)sk_new_null())
#define	sk_X509_INFO_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))
#define	sk_X509_INFO_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk));
#define	sk_X509_INFO_value(sk, i)
#define	sk_X509_INFO_set(sk, i, p)
#define	sk_X509_INFO_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))
#define	sk_X509_INFO_pop_free(sk, free_func)
#define	sk_X509_INFO_insert(sk, p, where)
#define	sk_X509_INFO_delete(sk, where)
#define	sk_X509_INFO_delete_ptr(sk, p)
#define	sk_X509_INFO_find(sk, out_index, p)
#define	sk_X509_INFO_shift(sk)   ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))
#define	sk_X509_INFO_push(sk, p)
#define	sk_X509_INFO_pop(sk)   ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)))
#define	sk_X509_INFO_dup(sk)
#define	sk_X509_INFO_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))
#define	sk_X509_INFO_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))
#define	sk_X509_INFO_set_cmp_func(sk, comp)
#define	sk_X509_INFO_deep_copy(sk, copy_func, free_func)
#define	sk_X509_LOOKUP_new(comp)
#define	sk_X509_LOOKUP_new_null()   ((STACK_OF(X509_LOOKUP) *)sk_new_null())
#define	sk_X509_LOOKUP_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))
#define	sk_X509_LOOKUP_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk));
#define	sk_X509_LOOKUP_value(sk, i)
#define	sk_X509_LOOKUP_set(sk, i, p)
#define	sk_X509_LOOKUP_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))
#define	sk_X509_LOOKUP_pop_free(sk, free_func)
#define	sk_X509_LOOKUP_insert(sk, p, where)
#define	sk_X509_LOOKUP_delete(sk, where)
#define	sk_X509_LOOKUP_delete_ptr(sk, p)
#define	sk_X509_LOOKUP_find(sk, out_index, p)
#define	sk_X509_LOOKUP_shift(sk)   ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))
#define	sk_X509_LOOKUP_push(sk, p)
#define	sk_X509_LOOKUP_pop(sk)   ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)))
#define	sk_X509_LOOKUP_dup(sk)
#define	sk_X509_LOOKUP_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))
#define	sk_X509_LOOKUP_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))
#define	sk_X509_LOOKUP_set_cmp_func(sk, comp)
#define	sk_X509_LOOKUP_deep_copy(sk, copy_func, free_func)
#define	sk_X509_NAME_new(comp)
#define	sk_X509_NAME_new_null()   ((STACK_OF(X509_NAME) *)sk_new_null())
#define	sk_X509_NAME_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))
#define	sk_X509_NAME_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk));
#define	sk_X509_NAME_value(sk, i)
#define	sk_X509_NAME_set(sk, i, p)
#define	sk_X509_NAME_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))
#define	sk_X509_NAME_pop_free(sk, free_func)
#define	sk_X509_NAME_insert(sk, p, where)
#define	sk_X509_NAME_delete(sk, where)
#define	sk_X509_NAME_delete_ptr(sk, p)
#define	sk_X509_NAME_find(sk, out_index, p)
#define	sk_X509_NAME_shift(sk)   ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))
#define	sk_X509_NAME_push(sk, p)
#define	sk_X509_NAME_pop(sk)   ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)))
#define	sk_X509_NAME_dup(sk)
#define	sk_X509_NAME_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))
#define	sk_X509_NAME_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))
#define	sk_X509_NAME_set_cmp_func(sk, comp)
#define	sk_X509_NAME_deep_copy(sk, copy_func, free_func)
#define	sk_X509_NAME_ENTRY_new(comp)
#define	sk_X509_NAME_ENTRY_new_null()   ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())
#define	sk_X509_NAME_ENTRY_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))
#define	sk_X509_NAME_ENTRY_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk));
#define	sk_X509_NAME_ENTRY_value(sk, i)
#define	sk_X509_NAME_ENTRY_set(sk, i, p)
#define	sk_X509_NAME_ENTRY_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
#define	sk_X509_NAME_ENTRY_pop_free(sk, free_func)
#define	sk_X509_NAME_ENTRY_insert(sk, p, where)
#define	sk_X509_NAME_ENTRY_delete(sk, where)
#define	sk_X509_NAME_ENTRY_delete_ptr(sk, p)
#define	sk_X509_NAME_ENTRY_find(sk, out_index, p)
#define	sk_X509_NAME_ENTRY_shift(sk)
#define	sk_X509_NAME_ENTRY_push(sk, p)
#define	sk_X509_NAME_ENTRY_pop(sk)
#define	sk_X509_NAME_ENTRY_dup(sk)
#define	sk_X509_NAME_ENTRY_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))
#define	sk_X509_NAME_ENTRY_is_sorted(sk)
#define	sk_X509_NAME_ENTRY_set_cmp_func(sk, comp)
#define	sk_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func)
#define	sk_X509_OBJECT_new(comp)
#define	sk_X509_OBJECT_new_null()   ((STACK_OF(X509_OBJECT) *)sk_new_null())
#define	sk_X509_OBJECT_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))
#define	sk_X509_OBJECT_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk));
#define	sk_X509_OBJECT_value(sk, i)
#define	sk_X509_OBJECT_set(sk, i, p)
#define	sk_X509_OBJECT_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))
#define	sk_X509_OBJECT_pop_free(sk, free_func)
#define	sk_X509_OBJECT_insert(sk, p, where)
#define	sk_X509_OBJECT_delete(sk, where)
#define	sk_X509_OBJECT_delete_ptr(sk, p)
#define	sk_X509_OBJECT_find(sk, out_index, p)
#define	sk_X509_OBJECT_shift(sk)   ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))
#define	sk_X509_OBJECT_push(sk, p)
#define	sk_X509_OBJECT_pop(sk)   ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))
#define	sk_X509_OBJECT_dup(sk)
#define	sk_X509_OBJECT_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))
#define	sk_X509_OBJECT_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))
#define	sk_X509_OBJECT_set_cmp_func(sk, comp)
#define	sk_X509_OBJECT_deep_copy(sk, copy_func, free_func)
#define	sk_X509_POLICY_DATA_new(comp)
#define	sk_X509_POLICY_DATA_new_null()   ((STACK_OF(X509_POLICY_DATA) *)sk_new_null())
#define	sk_X509_POLICY_DATA_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))
#define	sk_X509_POLICY_DATA_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));
#define	sk_X509_POLICY_DATA_value(sk, i)
#define	sk_X509_POLICY_DATA_set(sk, i, p)
#define	sk_X509_POLICY_DATA_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))
#define	sk_X509_POLICY_DATA_pop_free(sk, free_func)
#define	sk_X509_POLICY_DATA_insert(sk, p, where)
#define	sk_X509_POLICY_DATA_delete(sk, where)
#define	sk_X509_POLICY_DATA_delete_ptr(sk, p)
#define	sk_X509_POLICY_DATA_find(sk, out_index, p)
#define	sk_X509_POLICY_DATA_shift(sk)
#define	sk_X509_POLICY_DATA_push(sk, p)
#define	sk_X509_POLICY_DATA_pop(sk)
#define	sk_X509_POLICY_DATA_dup(sk)
#define	sk_X509_POLICY_DATA_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))
#define	sk_X509_POLICY_DATA_is_sorted(sk)
#define	sk_X509_POLICY_DATA_set_cmp_func(sk, comp)
#define	sk_X509_POLICY_DATA_deep_copy(sk, copy_func, free_func)
#define	sk_X509_POLICY_NODE_new(comp)
#define	sk_X509_POLICY_NODE_new_null()   ((STACK_OF(X509_POLICY_NODE) *)sk_new_null())
#define	sk_X509_POLICY_NODE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))
#define	sk_X509_POLICY_NODE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));
#define	sk_X509_POLICY_NODE_value(sk, i)
#define	sk_X509_POLICY_NODE_set(sk, i, p)
#define	sk_X509_POLICY_NODE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))
#define	sk_X509_POLICY_NODE_pop_free(sk, free_func)
#define	sk_X509_POLICY_NODE_insert(sk, p, where)
#define	sk_X509_POLICY_NODE_delete(sk, where)
#define	sk_X509_POLICY_NODE_delete_ptr(sk, p)
#define	sk_X509_POLICY_NODE_find(sk, out_index, p)
#define	sk_X509_POLICY_NODE_shift(sk)
#define	sk_X509_POLICY_NODE_push(sk, p)
#define	sk_X509_POLICY_NODE_pop(sk)
#define	sk_X509_POLICY_NODE_dup(sk)
#define	sk_X509_POLICY_NODE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))
#define	sk_X509_POLICY_NODE_is_sorted(sk)
#define	sk_X509_POLICY_NODE_set_cmp_func(sk, comp)
#define	sk_X509_POLICY_NODE_deep_copy(sk, copy_func, free_func)
#define	sk_X509_PURPOSE_new(comp)
#define	sk_X509_PURPOSE_new_null()   ((STACK_OF(X509_PURPOSE) *)sk_new_null())
#define	sk_X509_PURPOSE_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))
#define	sk_X509_PURPOSE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));
#define	sk_X509_PURPOSE_value(sk, i)
#define	sk_X509_PURPOSE_set(sk, i, p)
#define	sk_X509_PURPOSE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))
#define	sk_X509_PURPOSE_pop_free(sk, free_func)
#define	sk_X509_PURPOSE_insert(sk, p, where)
#define	sk_X509_PURPOSE_delete(sk, where)
#define	sk_X509_PURPOSE_delete_ptr(sk, p)
#define	sk_X509_PURPOSE_find(sk, out_index, p)
#define	sk_X509_PURPOSE_shift(sk)
#define	sk_X509_PURPOSE_push(sk, p)
#define	sk_X509_PURPOSE_pop(sk)   ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))
#define	sk_X509_PURPOSE_dup(sk)
#define	sk_X509_PURPOSE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))
#define	sk_X509_PURPOSE_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))
#define	sk_X509_PURPOSE_set_cmp_func(sk, comp)
#define	sk_X509_PURPOSE_deep_copy(sk, copy_func, free_func)
#define	sk_X509_REVOKED_new(comp)
#define	sk_X509_REVOKED_new_null()   ((STACK_OF(X509_REVOKED) *)sk_new_null())
#define	sk_X509_REVOKED_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))
#define	sk_X509_REVOKED_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));
#define	sk_X509_REVOKED_value(sk, i)
#define	sk_X509_REVOKED_set(sk, i, p)
#define	sk_X509_REVOKED_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))
#define	sk_X509_REVOKED_pop_free(sk, free_func)
#define	sk_X509_REVOKED_insert(sk, p, where)
#define	sk_X509_REVOKED_delete(sk, where)
#define	sk_X509_REVOKED_delete_ptr(sk, p)
#define	sk_X509_REVOKED_find(sk, out_index, p)
#define	sk_X509_REVOKED_shift(sk)
#define	sk_X509_REVOKED_push(sk, p)
#define	sk_X509_REVOKED_pop(sk)   ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))
#define	sk_X509_REVOKED_dup(sk)
#define	sk_X509_REVOKED_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))
#define	sk_X509_REVOKED_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))
#define	sk_X509_REVOKED_set_cmp_func(sk, comp)
#define	sk_X509_REVOKED_deep_copy(sk, copy_func, free_func)
#define	sk_X509_TRUST_new(comp)
#define	sk_X509_TRUST_new_null()   ((STACK_OF(X509_TRUST) *)sk_new_null())
#define	sk_X509_TRUST_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))
#define	sk_X509_TRUST_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));
#define	sk_X509_TRUST_value(sk, i)
#define	sk_X509_TRUST_set(sk, i, p)
#define	sk_X509_TRUST_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))
#define	sk_X509_TRUST_pop_free(sk, free_func)
#define	sk_X509_TRUST_insert(sk, p, where)
#define	sk_X509_TRUST_delete(sk, where)
#define	sk_X509_TRUST_delete_ptr(sk, p)
#define	sk_X509_TRUST_find(sk, out_index, p)
#define	sk_X509_TRUST_shift(sk)   ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))
#define	sk_X509_TRUST_push(sk, p)
#define	sk_X509_TRUST_pop(sk)   ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))
#define	sk_X509_TRUST_dup(sk)
#define	sk_X509_TRUST_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))
#define	sk_X509_TRUST_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))
#define	sk_X509_TRUST_set_cmp_func(sk, comp)
#define	sk_X509_TRUST_deep_copy(sk, copy_func, free_func)
#define	sk_X509_VERIFY_PARAM_new(comp)
#define	sk_X509_VERIFY_PARAM_new_null()   ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())
#define	sk_X509_VERIFY_PARAM_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))
#define	sk_X509_VERIFY_PARAM_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));
#define	sk_X509_VERIFY_PARAM_value(sk, i)
#define	sk_X509_VERIFY_PARAM_set(sk, i, p)
#define	sk_X509_VERIFY_PARAM_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))
#define	sk_X509_VERIFY_PARAM_pop_free(sk, free_func)
#define	sk_X509_VERIFY_PARAM_insert(sk, p, where)
#define	sk_X509_VERIFY_PARAM_delete(sk, where)
#define	sk_X509_VERIFY_PARAM_delete_ptr(sk, p)
#define	sk_X509_VERIFY_PARAM_find(sk, out_index, p)
#define	sk_X509_VERIFY_PARAM_shift(sk)
#define	sk_X509_VERIFY_PARAM_push(sk, p)
#define	sk_X509_VERIFY_PARAM_pop(sk)
#define	sk_X509_VERIFY_PARAM_dup(sk)
#define	sk_X509_VERIFY_PARAM_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))
#define	sk_X509_VERIFY_PARAM_is_sorted(sk)
#define	sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp)
#define	sk_X509_VERIFY_PARAM_deep_copy(sk, copy_func, free_func)
#define	sk_void_new(comp)
#define	sk_void_new_null()   ((STACK_OF(void) *)sk_new_null())
#define	sk_void_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))
#define	sk_void_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk));
#define	sk_void_value(sk, i)
#define	sk_void_set(sk, i, p)
#define	sk_void_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))
#define	sk_void_pop_free(sk, free_func)
#define	sk_void_insert(sk, p, where)
#define	sk_void_delete(sk, where)   ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (where)))
#define	sk_void_delete_ptr(sk, p)
#define	sk_void_find(sk, out_index, p)
#define	sk_void_shift(sk)   ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))
#define	sk_void_push(sk, p)
#define	sk_void_pop(sk)   ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))
#define	sk_void_dup(sk)
#define	sk_void_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))
#define	sk_void_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))
#define	sk_void_set_cmp_func(sk, comp)
#define	sk_void_deep_copy(sk, copy_func, free_func)
#define	sk_SRTP_PROTECTION_PROFILE_new(comp)
#define	sk_SRTP_PROTECTION_PROFILE_new_null()   ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())
#define	sk_SRTP_PROTECTION_PROFILE_num(sk)
#define	sk_SRTP_PROTECTION_PROFILE_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));
#define	sk_SRTP_PROTECTION_PROFILE_value(sk, i)
#define	sk_SRTP_PROTECTION_PROFILE_set(sk, i, p)
#define	sk_SRTP_PROTECTION_PROFILE_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
#define	sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func)
#define	sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where)
#define	sk_SRTP_PROTECTION_PROFILE_delete(sk, where)
#define	sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p)
#define	sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p)
#define	sk_SRTP_PROTECTION_PROFILE_shift(sk)
#define	sk_SRTP_PROTECTION_PROFILE_push(sk, p)
#define	sk_SRTP_PROTECTION_PROFILE_pop(sk)
#define	sk_SRTP_PROTECTION_PROFILE_dup(sk)
#define	sk_SRTP_PROTECTION_PROFILE_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))
#define	sk_SRTP_PROTECTION_PROFILE_is_sorted(sk)
#define	sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp)
#define	sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copy_func, free_func)
#define	sk_SSL_CIPHER_new(comp)
#define	sk_SSL_CIPHER_new_null()   ((STACK_OF(SSL_CIPHER) *)sk_new_null())
#define	sk_SSL_CIPHER_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))
#define	sk_SSL_CIPHER_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));
#define	sk_SSL_CIPHER_value(sk, i)
#define	sk_SSL_CIPHER_set(sk, i, p)
#define	sk_SSL_CIPHER_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))
#define	sk_SSL_CIPHER_pop_free(sk, free_func)
#define	sk_SSL_CIPHER_insert(sk, p, where)
#define	sk_SSL_CIPHER_delete(sk, where)
#define	sk_SSL_CIPHER_delete_ptr(sk, p)
#define	sk_SSL_CIPHER_find(sk, out_index, p)
#define	sk_SSL_CIPHER_shift(sk)
#define	sk_SSL_CIPHER_push(sk, p)
#define	sk_SSL_CIPHER_pop(sk)
#define	sk_SSL_CIPHER_dup(sk)
#define	sk_SSL_CIPHER_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))
#define	sk_SSL_CIPHER_is_sorted(sk)   sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))
#define	sk_SSL_CIPHER_set_cmp_func(sk, comp)
#define	sk_SSL_CIPHER_deep_copy(sk, copy_func, free_func)
#define	sk_OPENSSL_STRING_new(comp)
#define	sk_OPENSSL_STRING_new_null()   ((STACK_OF(OPENSSL_STRING) *)sk_new_null())
#define	sk_OPENSSL_STRING_num(sk)   sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))
#define	sk_OPENSSL_STRING_zero(sk)   sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));
#define	sk_OPENSSL_STRING_value(sk, i)
#define	sk_OPENSSL_STRING_set(sk, i, p)
#define	sk_OPENSSL_STRING_free(sk)   sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))
#define	sk_OPENSSL_STRING_pop_free(sk, free_func)
#define	sk_OPENSSL_STRING_insert(sk, p, where)
#define	sk_OPENSSL_STRING_delete(sk, where)
#define	sk_OPENSSL_STRING_delete_ptr(sk, p)
#define	sk_OPENSSL_STRING_find(sk, out_index, p)
#define	sk_OPENSSL_STRING_shift(sk)
#define	sk_OPENSSL_STRING_push(sk, p)
#define	sk_OPENSSL_STRING_pop(sk)
#define	sk_OPENSSL_STRING_dup(sk)
#define	sk_OPENSSL_STRING_sort(sk)   sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))
#define	sk_OPENSSL_STRING_is_sorted(sk)
#define	sk_OPENSSL_STRING_set_cmp_func(sk, comp)
#define	sk_OPENSSL_STRING_deep_copy(sk, copy_func, free_func)

Macro Definition Documentation

sk_ACCESS_DESCRIPTION_deep_copy

#define sk_ACCESS_DESCRIPTION_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ACCESS_DESCRIPTION) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                         \
                   ACCESS_DESCRIPTION *(*)(ACCESS_DESCRIPTION *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *),          \
                   free_func)))

sk_ACCESS_DESCRIPTION_delete

#define sk_ACCESS_DESCRIPTION_delete	(		sk,
			where
	)

Value:

((ACCESS_DESCRIPTION *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (where)))

sk_ACCESS_DESCRIPTION_delete_ptr

#define sk_ACCESS_DESCRIPTION_delete_ptr	(		sk,
			p
	)

Value:

((ACCESS_DESCRIPTION *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
      CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))

sk_ACCESS_DESCRIPTION_dup

#define sk_ACCESS_DESCRIPTION_dup

(

sk

)

Value:

((STACK_OF(ACCESS_DESCRIPTION) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk)))

sk_ACCESS_DESCRIPTION_find

#define sk_ACCESS_DESCRIPTION_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
          (out_index), CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))

sk_ACCESS_DESCRIPTION_free

#define sk_ACCESS_DESCRIPTION_free

(

sk

)

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

sk_ACCESS_DESCRIPTION_insert

#define sk_ACCESS_DESCRIPTION_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
            CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p), (where))

sk_ACCESS_DESCRIPTION_is_sorted

#define sk_ACCESS_DESCRIPTION_is_sorted

(

sk

)

Value:

sk_is_sorted(                             \
      CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk))

sk_ACCESS_DESCRIPTION_new

#define sk_ACCESS_DESCRIPTION_new

(

comp

)

Value:

((STACK_OF(ACCESS_DESCRIPTION) *)sk_new(CHECKED_CAST(                    \
      stack_cmp_func,                                                      \
      int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b), \
      comp)))

sk_ACCESS_DESCRIPTION_new_null

#define sk_ACCESS_DESCRIPTION_new_null

(

)

((STACK_OF(ACCESS_DESCRIPTION) *)sk_new_null())

sk_ACCESS_DESCRIPTION_num

#define sk_ACCESS_DESCRIPTION_num

(

sk

)

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

sk_ACCESS_DESCRIPTION_pop

#define sk_ACCESS_DESCRIPTION_pop

(

sk

)

Value:

((ACCESS_DESCRIPTION *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))

sk_ACCESS_DESCRIPTION_pop_free

#define sk_ACCESS_DESCRIPTION_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *), \
                           free_func))

sk_ACCESS_DESCRIPTION_push

#define sk_ACCESS_DESCRIPTION_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \
          CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))

sk_ACCESS_DESCRIPTION_set

#define sk_ACCESS_DESCRIPTION_set	(		sk,
			i,
			p
	)

Value:

((ACCESS_DESCRIPTION *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (i), \
      CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)))

sk_ACCESS_DESCRIPTION_set_cmp_func

#define sk_ACCESS_DESCRIPTION_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b))       \
       sk_set_cmp_func(                                                        \
           CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const ACCESS_DESCRIPTION **a,  \
                                                const ACCESS_DESCRIPTION **b), \
                        comp)))

sk_ACCESS_DESCRIPTION_shift

#define sk_ACCESS_DESCRIPTION_shift

(

sk

)

Value:

((ACCESS_DESCRIPTION *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)))

sk_ACCESS_DESCRIPTION_sort

#define sk_ACCESS_DESCRIPTION_sort

(

sk

)

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

sk_ACCESS_DESCRIPTION_value

#define sk_ACCESS_DESCRIPTION_value	(		sk,
			i
	)

Value:

((ACCESS_DESCRIPTION *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), \
      (i)))

sk_ACCESS_DESCRIPTION_zero

#define sk_ACCESS_DESCRIPTION_zero

(

sk

)

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

sk_ASN1_ADB_TABLE_deep_copy

#define sk_ASN1_ADB_TABLE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_ADB_TABLE) *)sk_deep_copy(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk),    \
      CHECKED_CAST(void *(*)(void *), ASN1_ADB_TABLE *(*)(ASN1_ADB_TABLE *), \
                   copy_func),                                               \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func)))

sk_ASN1_ADB_TABLE_delete

#define sk_ASN1_ADB_TABLE_delete	(		sk,
			where
	)

Value:

((ASN1_ADB_TABLE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (where)))

sk_ASN1_ADB_TABLE_delete_ptr

#define sk_ASN1_ADB_TABLE_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_ADB_TABLE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
      CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))

sk_ASN1_ADB_TABLE_dup

#define sk_ASN1_ADB_TABLE_dup

(

sk

)

Value:

((STACK_OF(ASN1_ADB_TABLE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk)))

sk_ASN1_ADB_TABLE_find

#define sk_ASN1_ADB_TABLE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (out_index), \
          CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))

sk_ASN1_ADB_TABLE_free

#define sk_ASN1_ADB_TABLE_free

(

sk

)

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

sk_ASN1_ADB_TABLE_insert

#define sk_ASN1_ADB_TABLE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
            CHECKED_CAST(void *, ASN1_ADB_TABLE *, p), (where))

sk_ASN1_ADB_TABLE_is_sorted

#define sk_ASN1_ADB_TABLE_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))

sk_ASN1_ADB_TABLE_new

#define sk_ASN1_ADB_TABLE_new

(

comp

)

Value:

((STACK_OF(ASN1_ADB_TABLE) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b), comp)))

sk_ASN1_ADB_TABLE_new_null

#define sk_ASN1_ADB_TABLE_new_null

(

)

((STACK_OF(ASN1_ADB_TABLE) *)sk_new_null())

sk_ASN1_ADB_TABLE_num

#define sk_ASN1_ADB_TABLE_num

(

sk

)

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

sk_ASN1_ADB_TABLE_pop

#define sk_ASN1_ADB_TABLE_pop

(

sk

)

Value:

((ASN1_ADB_TABLE *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))

sk_ASN1_ADB_TABLE_pop_free

#define sk_ASN1_ADB_TABLE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func))

sk_ASN1_ADB_TABLE_push

#define sk_ASN1_ADB_TABLE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \
          CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))

sk_ASN1_ADB_TABLE_set

#define sk_ASN1_ADB_TABLE_set	(		sk,
			i,
			p
	)

Value:

((ASN1_ADB_TABLE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (i), \
      CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)))

sk_ASN1_ADB_TABLE_set_cmp_func

#define sk_ASN1_ADB_TABLE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_ADB_TABLE **a,  \
                                                const ASN1_ADB_TABLE **b), \
                        comp)))

sk_ASN1_ADB_TABLE_shift

#define sk_ASN1_ADB_TABLE_shift

(

sk

)

Value:

((ASN1_ADB_TABLE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)))

sk_ASN1_ADB_TABLE_sort

#define sk_ASN1_ADB_TABLE_sort

(

sk

)

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

sk_ASN1_ADB_TABLE_value

#define sk_ASN1_ADB_TABLE_value	(		sk,
			i
	)

Value:

((ASN1_ADB_TABLE *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk), \
      (i)))

sk_ASN1_ADB_TABLE_zero

#define sk_ASN1_ADB_TABLE_zero

(

sk

)

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

sk_ASN1_GENERALSTRING_deep_copy

#define sk_ASN1_GENERALSTRING_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_GENERALSTRING) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                         \
                   ASN1_GENERALSTRING *(*)(ASN1_GENERALSTRING *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *),          \
                   free_func)))

sk_ASN1_GENERALSTRING_delete

#define sk_ASN1_GENERALSTRING_delete	(		sk,
			where
	)

Value:

((ASN1_GENERALSTRING *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (where)))

sk_ASN1_GENERALSTRING_delete_ptr

#define sk_ASN1_GENERALSTRING_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_GENERALSTRING *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
      CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))

sk_ASN1_GENERALSTRING_dup

#define sk_ASN1_GENERALSTRING_dup

(

sk

)

Value:

((STACK_OF(ASN1_GENERALSTRING) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk)))

sk_ASN1_GENERALSTRING_find

#define sk_ASN1_GENERALSTRING_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
          (out_index), CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))

sk_ASN1_GENERALSTRING_free

#define sk_ASN1_GENERALSTRING_free

(

sk

)

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

sk_ASN1_GENERALSTRING_insert

#define sk_ASN1_GENERALSTRING_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
            CHECKED_CAST(void *, ASN1_GENERALSTRING *, p), (where))

sk_ASN1_GENERALSTRING_is_sorted

#define sk_ASN1_GENERALSTRING_is_sorted

(

sk

)

Value:

sk_is_sorted(                             \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))

sk_ASN1_GENERALSTRING_new

#define sk_ASN1_GENERALSTRING_new

(

comp

)

Value:

((STACK_OF(ASN1_GENERALSTRING) *)sk_new(CHECKED_CAST(                    \
      stack_cmp_func,                                                      \
      int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b), \
      comp)))

sk_ASN1_GENERALSTRING_new_null

#define sk_ASN1_GENERALSTRING_new_null

(

)

((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null())

sk_ASN1_GENERALSTRING_num

#define sk_ASN1_GENERALSTRING_num

(

sk

)

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

sk_ASN1_GENERALSTRING_pop

#define sk_ASN1_GENERALSTRING_pop

(

sk

)

Value:

((ASN1_GENERALSTRING *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))

sk_ASN1_GENERALSTRING_pop_free

#define sk_ASN1_GENERALSTRING_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *), \
                           free_func))

sk_ASN1_GENERALSTRING_push

#define sk_ASN1_GENERALSTRING_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \
          CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))

sk_ASN1_GENERALSTRING_set

#define sk_ASN1_GENERALSTRING_set	(		sk,
			i,
			p
	)

Value:

((ASN1_GENERALSTRING *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (i), \
      CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)))

sk_ASN1_GENERALSTRING_set_cmp_func

#define sk_ASN1_GENERALSTRING_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b))       \
       sk_set_cmp_func(                                                        \
           CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_GENERALSTRING **a,  \
                                                const ASN1_GENERALSTRING **b), \
                        comp)))

sk_ASN1_GENERALSTRING_shift

#define sk_ASN1_GENERALSTRING_shift

(

sk

)

Value:

((ASN1_GENERALSTRING *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)))

sk_ASN1_GENERALSTRING_sort

#define sk_ASN1_GENERALSTRING_sort

(

sk

)

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

sk_ASN1_GENERALSTRING_value

#define sk_ASN1_GENERALSTRING_value	(		sk,
			i
	)

Value:

((ASN1_GENERALSTRING *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), \
      (i)))

sk_ASN1_GENERALSTRING_zero

#define sk_ASN1_GENERALSTRING_zero

(

sk

)

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

sk_ASN1_INTEGER_deep_copy

#define sk_ASN1_INTEGER_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_INTEGER) *)sk_deep_copy(                               \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk),  \
      CHECKED_CAST(void *(*)(void *), ASN1_INTEGER *(*)(ASN1_INTEGER *), \
                   copy_func),                                           \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func)))

sk_ASN1_INTEGER_delete

#define sk_ASN1_INTEGER_delete	(		sk,
			where
	)

Value:

((ASN1_INTEGER *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (where)))

sk_ASN1_INTEGER_delete_ptr

#define sk_ASN1_INTEGER_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_INTEGER *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
      CHECKED_CAST(void *, ASN1_INTEGER *, p)))

sk_ASN1_INTEGER_dup

#define sk_ASN1_INTEGER_dup

(

sk

)

Value:

((STACK_OF(ASN1_INTEGER) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk)))

sk_ASN1_INTEGER_find

#define sk_ASN1_INTEGER_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (out_index), \
          CHECKED_CAST(void *, ASN1_INTEGER *, p))

sk_ASN1_INTEGER_free

#define sk_ASN1_INTEGER_free

(

sk

)

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

sk_ASN1_INTEGER_insert

#define sk_ASN1_INTEGER_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
            CHECKED_CAST(void *, ASN1_INTEGER *, p), (where))

sk_ASN1_INTEGER_is_sorted

#define sk_ASN1_INTEGER_is_sorted

(

sk

)

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

sk_ASN1_INTEGER_new

#define sk_ASN1_INTEGER_new

(

comp

)

Value:

((STACK_OF(ASN1_INTEGER) *)sk_new(CHECKED_CAST(                              \
      stack_cmp_func, int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \
      comp)))

sk_ASN1_INTEGER_new_null

#define sk_ASN1_INTEGER_new_null

(

)

((STACK_OF(ASN1_INTEGER) *)sk_new_null())

sk_ASN1_INTEGER_num

#define sk_ASN1_INTEGER_num

(

sk

)

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

sk_ASN1_INTEGER_pop

#define sk_ASN1_INTEGER_pop

(

sk

)

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

sk_ASN1_INTEGER_pop_free

#define sk_ASN1_INTEGER_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                              \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func))

sk_ASN1_INTEGER_push

#define sk_ASN1_INTEGER_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \
          CHECKED_CAST(void *, ASN1_INTEGER *, p))

sk_ASN1_INTEGER_set

#define sk_ASN1_INTEGER_set	(		sk,
			i,
			p
	)

Value:

((ASN1_INTEGER *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (i), \
      CHECKED_CAST(void *, ASN1_INTEGER *, p)))

sk_ASN1_INTEGER_set_cmp_func

#define sk_ASN1_INTEGER_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk),                  \
      CHECKED_CAST(stack_cmp_func,                                           \
                   int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b),  \
                   comp)))

sk_ASN1_INTEGER_shift

#define sk_ASN1_INTEGER_shift

(

sk

)

Value:

((ASN1_INTEGER *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)))

sk_ASN1_INTEGER_sort

#define sk_ASN1_INTEGER_sort

(

sk

)

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

sk_ASN1_INTEGER_value

#define sk_ASN1_INTEGER_value	(		sk,
			i
	)

Value:

((ASN1_INTEGER *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk), (i)))

sk_ASN1_INTEGER_zero

#define sk_ASN1_INTEGER_zero

(

sk

)

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

sk_ASN1_OBJECT_deep_copy

#define sk_ASN1_OBJECT_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_OBJECT) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk), \
      CHECKED_CAST(void *(*)(void *), ASN1_OBJECT *(*)(ASN1_OBJECT *), \
                   copy_func),                                         \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func)))

sk_ASN1_OBJECT_delete

#define sk_ASN1_OBJECT_delete	(		sk,
			where
	)

Value:

((ASN1_OBJECT *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (where)))

sk_ASN1_OBJECT_delete_ptr

#define sk_ASN1_OBJECT_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_OBJECT *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
      CHECKED_CAST(void *, ASN1_OBJECT *, p)))

sk_ASN1_OBJECT_dup

#define sk_ASN1_OBJECT_dup

(

sk

)

Value:

((STACK_OF(ASN1_OBJECT) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk)))

sk_ASN1_OBJECT_find

#define sk_ASN1_OBJECT_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (out_index), \
          CHECKED_CAST(void *, ASN1_OBJECT *, p))

sk_ASN1_OBJECT_free

#define sk_ASN1_OBJECT_free

(

sk

)

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

sk_ASN1_OBJECT_insert

#define sk_ASN1_OBJECT_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
            CHECKED_CAST(void *, ASN1_OBJECT *, p), (where))

sk_ASN1_OBJECT_is_sorted

#define sk_ASN1_OBJECT_is_sorted

(

sk

)

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

sk_ASN1_OBJECT_new

#define sk_ASN1_OBJECT_new

(

comp

)

Value:

((STACK_OF(ASN1_OBJECT) *)sk_new(CHECKED_CAST(                             \
      stack_cmp_func, int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \
      comp)))

sk_ASN1_OBJECT_new_null

#define sk_ASN1_OBJECT_new_null

(

)

((STACK_OF(ASN1_OBJECT) *)sk_new_null())

sk_ASN1_OBJECT_num

#define sk_ASN1_OBJECT_num

(

sk

)

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

sk_ASN1_OBJECT_pop

#define sk_ASN1_OBJECT_pop

(

sk

)

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

sk_ASN1_OBJECT_pop_free

#define sk_ASN1_OBJECT_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func))

sk_ASN1_OBJECT_push

#define sk_ASN1_OBJECT_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
          CHECKED_CAST(void *, ASN1_OBJECT *, p))

sk_ASN1_OBJECT_set

#define sk_ASN1_OBJECT_set	(		sk,
			i,
			p
	)

Value:

((ASN1_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \
                         (i), CHECKED_CAST(void *, ASN1_OBJECT *, p)))

sk_ASN1_OBJECT_set_cmp_func

#define sk_ASN1_OBJECT_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk),                 \
      CHECKED_CAST(stack_cmp_func,                                         \
                   int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b),  \
                   comp)))

sk_ASN1_OBJECT_shift

#define sk_ASN1_OBJECT_shift

(

sk

)

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

sk_ASN1_OBJECT_sort

#define sk_ASN1_OBJECT_sort

(

sk

)

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

sk_ASN1_OBJECT_value

#define sk_ASN1_OBJECT_value	(		sk,
			i
	)

Value:

((ASN1_OBJECT *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk), (i)))

sk_ASN1_OBJECT_zero

#define sk_ASN1_OBJECT_zero

(

sk

)

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

sk_ASN1_STRING_TABLE_deep_copy

#define sk_ASN1_STRING_TABLE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_STRING_TABLE) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                        \
                   ASN1_STRING_TABLE *(*)(ASN1_STRING_TABLE *), copy_func),  \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *),          \
                   free_func)))

sk_ASN1_STRING_TABLE_delete

#define sk_ASN1_STRING_TABLE_delete	(		sk,
			where
	)

Value:

((ASN1_STRING_TABLE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (where)))

sk_ASN1_STRING_TABLE_delete_ptr

#define sk_ASN1_STRING_TABLE_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_STRING_TABLE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
      CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))

sk_ASN1_STRING_TABLE_dup

#define sk_ASN1_STRING_TABLE_dup

(

sk

)

Value:

((STACK_OF(ASN1_STRING_TABLE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk)))

sk_ASN1_STRING_TABLE_find

#define sk_ASN1_STRING_TABLE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
          (out_index), CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))

sk_ASN1_STRING_TABLE_free

#define sk_ASN1_STRING_TABLE_free

(

sk

)

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

sk_ASN1_STRING_TABLE_insert

#define sk_ASN1_STRING_TABLE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
            CHECKED_CAST(void *, ASN1_STRING_TABLE *, p), (where))

sk_ASN1_STRING_TABLE_is_sorted

#define sk_ASN1_STRING_TABLE_is_sorted

(

sk

)

Value:

sk_is_sorted(                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))

sk_ASN1_STRING_TABLE_new

#define sk_ASN1_STRING_TABLE_new

(

comp

)

Value:

((STACK_OF(ASN1_STRING_TABLE) *)sk_new(CHECKED_CAST(                   \
      stack_cmp_func,                                                    \
      int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b), \
      comp)))

sk_ASN1_STRING_TABLE_new_null

#define sk_ASN1_STRING_TABLE_new_null

(

)

((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null())

sk_ASN1_STRING_TABLE_num

#define sk_ASN1_STRING_TABLE_num

(

sk

)

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

sk_ASN1_STRING_TABLE_pop

#define sk_ASN1_STRING_TABLE_pop

(

sk

)

Value:

((ASN1_STRING_TABLE *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))

sk_ASN1_STRING_TABLE_pop_free

#define sk_ASN1_STRING_TABLE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *), \
                           free_func))

sk_ASN1_STRING_TABLE_push

#define sk_ASN1_STRING_TABLE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \
          CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))

sk_ASN1_STRING_TABLE_set

#define sk_ASN1_STRING_TABLE_set	(		sk,
			i,
			p
	)

Value:

((ASN1_STRING_TABLE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (i), \
      CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)))

sk_ASN1_STRING_TABLE_set_cmp_func

#define sk_ASN1_STRING_TABLE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b))        \
       sk_set_cmp_func(                                                       \
           CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_STRING_TABLE **a,  \
                                                const ASN1_STRING_TABLE **b), \
                        comp)))

sk_ASN1_STRING_TABLE_shift

#define sk_ASN1_STRING_TABLE_shift

(

sk

)

Value:

((ASN1_STRING_TABLE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)))

sk_ASN1_STRING_TABLE_sort

#define sk_ASN1_STRING_TABLE_sort

(

sk

)

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

sk_ASN1_STRING_TABLE_value

#define sk_ASN1_STRING_TABLE_value	(		sk,
			i
	)

Value:

((ASN1_STRING_TABLE *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), \
      (i)))

sk_ASN1_STRING_TABLE_zero

#define sk_ASN1_STRING_TABLE_zero

(

sk

)

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

sk_ASN1_TYPE_deep_copy

#define sk_ASN1_TYPE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_TYPE) *)sk_deep_copy(                                        \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk),           \
      CHECKED_CAST(void *(*)(void *), ASN1_TYPE *(*)(ASN1_TYPE *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func)))

sk_ASN1_TYPE_delete

#define sk_ASN1_TYPE_delete	(		sk,
			where
	)

Value:

((ASN1_TYPE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
                          (where)))

sk_ASN1_TYPE_delete_ptr

#define sk_ASN1_TYPE_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_TYPE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
      CHECKED_CAST(void *, ASN1_TYPE *, p)))

sk_ASN1_TYPE_dup

#define sk_ASN1_TYPE_dup

(

sk

)

Value:

((STACK_OF(ASN1_TYPE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk)))

sk_ASN1_TYPE_find

#define sk_ASN1_TYPE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (out_index), \
          CHECKED_CAST(void *, ASN1_TYPE *, p))

sk_ASN1_TYPE_free

#define sk_ASN1_TYPE_free

(

sk

)

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

sk_ASN1_TYPE_insert

#define sk_ASN1_TYPE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
            CHECKED_CAST(void *, ASN1_TYPE *, p), (where))

sk_ASN1_TYPE_is_sorted

#define sk_ASN1_TYPE_is_sorted

(

sk

)

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

sk_ASN1_TYPE_new

#define sk_ASN1_TYPE_new

(

comp

)

Value:

((STACK_OF(ASN1_TYPE) *)sk_new(  \
      CHECKED_CAST(stack_cmp_func, \
                   int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))

sk_ASN1_TYPE_new_null

#define sk_ASN1_TYPE_new_null

(

)

((STACK_OF(ASN1_TYPE) *)sk_new_null())

sk_ASN1_TYPE_num

#define sk_ASN1_TYPE_num

(

sk

)

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

sk_ASN1_TYPE_pop

#define sk_ASN1_TYPE_pop

(

sk

)

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

sk_ASN1_TYPE_pop_free

#define sk_ASN1_TYPE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func))

sk_ASN1_TYPE_push

#define sk_ASN1_TYPE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \
          CHECKED_CAST(void *, ASN1_TYPE *, p))

sk_ASN1_TYPE_set

#define sk_ASN1_TYPE_set	(		sk,
			i,
			p
	)

Value:

((ASN1_TYPE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (i), \
                       CHECKED_CAST(void *, ASN1_TYPE *, p)))

sk_ASN1_TYPE_set_cmp_func

#define sk_ASN1_TYPE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk),               \
      CHECKED_CAST(stack_cmp_func,                                     \
                   int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp)))

sk_ASN1_TYPE_shift

#define sk_ASN1_TYPE_shift

(

sk

)

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

sk_ASN1_TYPE_sort

#define sk_ASN1_TYPE_sort

(

sk

)

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

sk_ASN1_TYPE_value

#define sk_ASN1_TYPE_value	(		sk,
			i
	)

Value:

((ASN1_TYPE *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk), (i)))

sk_ASN1_TYPE_zero

#define sk_ASN1_TYPE_zero

(

sk

)

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

sk_ASN1_VALUE_deep_copy

#define sk_ASN1_VALUE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(ASN1_VALUE) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk), \
      CHECKED_CAST(void *(*)(void *), ASN1_VALUE *(*)(ASN1_VALUE *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func)))

sk_ASN1_VALUE_delete

#define sk_ASN1_VALUE_delete	(		sk,
			where
	)

Value:

((ASN1_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
                           (where)))

sk_ASN1_VALUE_delete_ptr

#define sk_ASN1_VALUE_delete_ptr	(		sk,
			p
	)

Value:

((ASN1_VALUE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
      CHECKED_CAST(void *, ASN1_VALUE *, p)))

sk_ASN1_VALUE_dup

#define sk_ASN1_VALUE_dup

(

sk

)

Value:

((STACK_OF(ASN1_VALUE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk)))

sk_ASN1_VALUE_find

#define sk_ASN1_VALUE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), (out_index), \
          CHECKED_CAST(void *, ASN1_VALUE *, p))

sk_ASN1_VALUE_free

#define sk_ASN1_VALUE_free

(

sk

)

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

sk_ASN1_VALUE_insert

#define sk_ASN1_VALUE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
            CHECKED_CAST(void *, ASN1_VALUE *, p), (where))

sk_ASN1_VALUE_is_sorted

#define sk_ASN1_VALUE_is_sorted

(

sk

)

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

sk_ASN1_VALUE_new

#define sk_ASN1_VALUE_new

(

comp

)

Value:

((STACK_OF(ASN1_VALUE) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \
      comp)))

sk_ASN1_VALUE_new_null

#define sk_ASN1_VALUE_new_null

(

)

((STACK_OF(ASN1_VALUE) *)sk_new_null())

sk_ASN1_VALUE_num

#define sk_ASN1_VALUE_num

(

sk

)

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

sk_ASN1_VALUE_pop

#define sk_ASN1_VALUE_pop

(

sk

)

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

sk_ASN1_VALUE_pop_free

#define sk_ASN1_VALUE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func))

sk_ASN1_VALUE_push

#define sk_ASN1_VALUE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
          CHECKED_CAST(void *, ASN1_VALUE *, p))

sk_ASN1_VALUE_set

#define sk_ASN1_VALUE_set	(		sk,
			i,
			p
	)

Value:

((ASN1_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \
                        (i), CHECKED_CAST(void *, ASN1_VALUE *, p)))

sk_ASN1_VALUE_set_cmp_func

#define sk_ASN1_VALUE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b),  \
                   comp)))

sk_ASN1_VALUE_shift

#define sk_ASN1_VALUE_shift

(

sk

)

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

sk_ASN1_VALUE_sort

#define sk_ASN1_VALUE_sort

(

sk

)

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

sk_ASN1_VALUE_value

#define sk_ASN1_VALUE_value	(		sk,
			i
	)

Value:

((ASN1_VALUE *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk), (i)))

sk_ASN1_VALUE_zero

#define sk_ASN1_VALUE_zero

(

sk

)

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

sk_BIO_deep_copy

#define sk_BIO_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(BIO) *)sk_deep_copy(                                  \
      CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk),     \
      CHECKED_CAST(void *(*)(void *), BIO *(*)(BIO *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func)))

sk_BIO_delete

#define sk_BIO_delete	(		sk,
			where
	)		((BIO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (where)))

sk_BIO_delete_ptr

#define sk_BIO_delete_ptr	(		sk,
			p
	)

Value:

((BIO *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
                        CHECKED_CAST(void *, BIO *, p)))

sk_BIO_dup

#define sk_BIO_dup

(

sk

)

Value:

((STACK_OF(BIO) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk)))

sk_BIO_find

#define sk_BIO_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (out_index), \
          CHECKED_CAST(void *, BIO *, p))

sk_BIO_free

#define sk_BIO_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))

sk_BIO_insert

#define sk_BIO_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
            CHECKED_CAST(void *, BIO *, p), (where))

sk_BIO_is_sorted

#define sk_BIO_is_sorted

(

sk

)

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

sk_BIO_new

#define sk_BIO_new

(

comp

)

Value:

((STACK_OF(BIO) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const BIO **a, const BIO **b), comp)))

sk_BIO_new_null

#define sk_BIO_new_null

(

)

((STACK_OF(BIO) *)sk_new_null())

sk_BIO_num

#define sk_BIO_num

(

sk

)

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

sk_BIO_pop

#define sk_BIO_pop

(

sk

)

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

sk_BIO_pop_free

#define sk_BIO_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func))

sk_BIO_push

#define sk_BIO_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \
          CHECKED_CAST(void *, BIO *, p))

sk_BIO_set

#define sk_BIO_set	(		sk,
			i,
			p
	)

Value:

((BIO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (i), \
                 CHECKED_CAST(void *, BIO *, p)))

sk_BIO_set_cmp_func

#define sk_BIO_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const BIO **a, const BIO **b))sk_set_cmp_func(                \
      CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk),                        \
      CHECKED_CAST(stack_cmp_func, int (*)(const BIO **a, const BIO **b), \
                   comp)))

sk_BIO_shift

#define sk_BIO_shift

(

sk

)

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

sk_BIO_sort

#define sk_BIO_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))

sk_BIO_value

#define sk_BIO_value	(		sk,
			i
	)

Value:

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

sk_BIO_zero

#define sk_BIO_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk));

sk_BY_DIR_ENTRY_deep_copy

#define sk_BY_DIR_ENTRY_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(BY_DIR_ENTRY) *)sk_deep_copy(                               \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk),  \
      CHECKED_CAST(void *(*)(void *), BY_DIR_ENTRY *(*)(BY_DIR_ENTRY *), \
                   copy_func),                                           \
      CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func)))

sk_BY_DIR_ENTRY_delete

#define sk_BY_DIR_ENTRY_delete	(		sk,
			where
	)

Value:

((BY_DIR_ENTRY *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (where)))

sk_BY_DIR_ENTRY_delete_ptr

#define sk_BY_DIR_ENTRY_delete_ptr	(		sk,
			p
	)

Value:

((BY_DIR_ENTRY *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
      CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))

sk_BY_DIR_ENTRY_dup

#define sk_BY_DIR_ENTRY_dup

(

sk

)

Value:

((STACK_OF(BY_DIR_ENTRY) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk)))

sk_BY_DIR_ENTRY_find

#define sk_BY_DIR_ENTRY_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (out_index), \
          CHECKED_CAST(void *, BY_DIR_ENTRY *, p))

sk_BY_DIR_ENTRY_free

#define sk_BY_DIR_ENTRY_free

(

sk

)

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

sk_BY_DIR_ENTRY_insert

#define sk_BY_DIR_ENTRY_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
            CHECKED_CAST(void *, BY_DIR_ENTRY *, p), (where))

sk_BY_DIR_ENTRY_is_sorted

#define sk_BY_DIR_ENTRY_is_sorted

(

sk

)

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

sk_BY_DIR_ENTRY_new

#define sk_BY_DIR_ENTRY_new

(

comp

)

Value:

((STACK_OF(BY_DIR_ENTRY) *)sk_new(CHECKED_CAST(                              \
      stack_cmp_func, int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \
      comp)))

sk_BY_DIR_ENTRY_new_null

#define sk_BY_DIR_ENTRY_new_null

(

)

((STACK_OF(BY_DIR_ENTRY) *)sk_new_null())

sk_BY_DIR_ENTRY_num

#define sk_BY_DIR_ENTRY_num

(

sk

)

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

sk_BY_DIR_ENTRY_pop

#define sk_BY_DIR_ENTRY_pop

(

sk

)

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

sk_BY_DIR_ENTRY_pop_free

#define sk_BY_DIR_ENTRY_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                              \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func))

sk_BY_DIR_ENTRY_push

#define sk_BY_DIR_ENTRY_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \
          CHECKED_CAST(void *, BY_DIR_ENTRY *, p))

sk_BY_DIR_ENTRY_set

#define sk_BY_DIR_ENTRY_set	(		sk,
			i,
			p
	)

Value:

((BY_DIR_ENTRY *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (i), \
      CHECKED_CAST(void *, BY_DIR_ENTRY *, p)))

sk_BY_DIR_ENTRY_set_cmp_func

#define sk_BY_DIR_ENTRY_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk),                  \
      CHECKED_CAST(stack_cmp_func,                                           \
                   int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b),  \
                   comp)))

sk_BY_DIR_ENTRY_shift

#define sk_BY_DIR_ENTRY_shift

(

sk

)

Value:

((BY_DIR_ENTRY *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)))

sk_BY_DIR_ENTRY_sort

#define sk_BY_DIR_ENTRY_sort

(

sk

)

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

sk_BY_DIR_ENTRY_value

#define sk_BY_DIR_ENTRY_value	(		sk,
			i
	)

Value:

((BY_DIR_ENTRY *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk), (i)))

sk_BY_DIR_ENTRY_zero

#define sk_BY_DIR_ENTRY_zero

(

sk

)

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

sk_BY_DIR_HASH_deep_copy

#define sk_BY_DIR_HASH_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(BY_DIR_HASH) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk), \
      CHECKED_CAST(void *(*)(void *), BY_DIR_HASH *(*)(BY_DIR_HASH *), \
                   copy_func),                                         \
      CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func)))

sk_BY_DIR_HASH_delete

#define sk_BY_DIR_HASH_delete	(		sk,
			where
	)

Value:

((BY_DIR_HASH *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (where)))

sk_BY_DIR_HASH_delete_ptr

#define sk_BY_DIR_HASH_delete_ptr	(		sk,
			p
	)

Value:

((BY_DIR_HASH *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
      CHECKED_CAST(void *, BY_DIR_HASH *, p)))

sk_BY_DIR_HASH_dup

#define sk_BY_DIR_HASH_dup

(

sk

)

Value:

((STACK_OF(BY_DIR_HASH) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk)))

sk_BY_DIR_HASH_find

#define sk_BY_DIR_HASH_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (out_index), \
          CHECKED_CAST(void *, BY_DIR_HASH *, p))

sk_BY_DIR_HASH_free

#define sk_BY_DIR_HASH_free

(

sk

)

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

sk_BY_DIR_HASH_insert

#define sk_BY_DIR_HASH_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
            CHECKED_CAST(void *, BY_DIR_HASH *, p), (where))

sk_BY_DIR_HASH_is_sorted

#define sk_BY_DIR_HASH_is_sorted

(

sk

)

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

sk_BY_DIR_HASH_new

#define sk_BY_DIR_HASH_new

(

comp

)

Value:

((STACK_OF(BY_DIR_HASH) *)sk_new(CHECKED_CAST(                             \
      stack_cmp_func, int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \
      comp)))

sk_BY_DIR_HASH_new_null

#define sk_BY_DIR_HASH_new_null

(

)

((STACK_OF(BY_DIR_HASH) *)sk_new_null())

sk_BY_DIR_HASH_num

#define sk_BY_DIR_HASH_num

(

sk

)

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

sk_BY_DIR_HASH_pop

#define sk_BY_DIR_HASH_pop

(

sk

)

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

sk_BY_DIR_HASH_pop_free

#define sk_BY_DIR_HASH_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                             \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func))

sk_BY_DIR_HASH_push

#define sk_BY_DIR_HASH_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
          CHECKED_CAST(void *, BY_DIR_HASH *, p))

sk_BY_DIR_HASH_set

#define sk_BY_DIR_HASH_set	(		sk,
			i,
			p
	)

Value:

((BY_DIR_HASH *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \
                         (i), CHECKED_CAST(void *, BY_DIR_HASH *, p)))

sk_BY_DIR_HASH_set_cmp_func

#define sk_BY_DIR_HASH_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk),                 \
      CHECKED_CAST(stack_cmp_func,                                         \
                   int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b),  \
                   comp)))

sk_BY_DIR_HASH_shift

#define sk_BY_DIR_HASH_shift

(

sk

)

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

sk_BY_DIR_HASH_sort

#define sk_BY_DIR_HASH_sort

(

sk

)

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

sk_BY_DIR_HASH_value

#define sk_BY_DIR_HASH_value	(		sk,
			i
	)

Value:

((BY_DIR_HASH *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk), (i)))

sk_BY_DIR_HASH_zero

#define sk_BY_DIR_HASH_zero

(

sk

)

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

sk_CONF_VALUE_deep_copy

#define sk_CONF_VALUE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(CONF_VALUE) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk), \
      CHECKED_CAST(void *(*)(void *), CONF_VALUE *(*)(CONF_VALUE *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func)))

sk_CONF_VALUE_delete

#define sk_CONF_VALUE_delete	(		sk,
			where
	)

Value:

((CONF_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
                           (where)))

sk_CONF_VALUE_delete_ptr

#define sk_CONF_VALUE_delete_ptr	(		sk,
			p
	)

Value:

((CONF_VALUE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
      CHECKED_CAST(void *, CONF_VALUE *, p)))

sk_CONF_VALUE_dup

#define sk_CONF_VALUE_dup

(

sk

)

Value:

((STACK_OF(CONF_VALUE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk)))

sk_CONF_VALUE_find

#define sk_CONF_VALUE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), (out_index), \
          CHECKED_CAST(void *, CONF_VALUE *, p))

sk_CONF_VALUE_free

#define sk_CONF_VALUE_free

(

sk

)

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

sk_CONF_VALUE_insert

#define sk_CONF_VALUE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
            CHECKED_CAST(void *, CONF_VALUE *, p), (where))

sk_CONF_VALUE_is_sorted

#define sk_CONF_VALUE_is_sorted

(

sk

)

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

sk_CONF_VALUE_new

#define sk_CONF_VALUE_new

(

comp

)

Value:

((STACK_OF(CONF_VALUE) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \
      comp)))

sk_CONF_VALUE_new_null

#define sk_CONF_VALUE_new_null

(

)

((STACK_OF(CONF_VALUE) *)sk_new_null())

sk_CONF_VALUE_num

#define sk_CONF_VALUE_num

(

sk

)

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

sk_CONF_VALUE_pop

#define sk_CONF_VALUE_pop

(

sk

)

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

sk_CONF_VALUE_pop_free

#define sk_CONF_VALUE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func))

sk_CONF_VALUE_push

#define sk_CONF_VALUE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
          CHECKED_CAST(void *, CONF_VALUE *, p))

sk_CONF_VALUE_set

#define sk_CONF_VALUE_set	(		sk,
			i,
			p
	)

Value:

((CONF_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \
                        (i), CHECKED_CAST(void *, CONF_VALUE *, p)))

sk_CONF_VALUE_set_cmp_func

#define sk_CONF_VALUE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const CONF_VALUE **a, const CONF_VALUE **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const CONF_VALUE **a, const CONF_VALUE **b),  \
                   comp)))

sk_CONF_VALUE_shift

#define sk_CONF_VALUE_shift

(

sk

)

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

sk_CONF_VALUE_sort

#define sk_CONF_VALUE_sort

(

sk

)

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

sk_CONF_VALUE_value

#define sk_CONF_VALUE_value	(		sk,
			i
	)

Value:

((CONF_VALUE *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk), (i)))

sk_CONF_VALUE_zero

#define sk_CONF_VALUE_zero

(

sk

)

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

sk_CRYPTO_EX_DATA_FUNCS_deep_copy

#define sk_CRYPTO_EX_DATA_FUNCS_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_deep_copy(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \
                   sk),                                                    \
      CHECKED_CAST(void *(*)(void *),                                      \
                   CRYPTO_EX_DATA_FUNCS *(*)(CRYPTO_EX_DATA_FUNCS *),      \
                   copy_func),                                             \
      CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *),     \
                   free_func)))

sk_CRYPTO_EX_DATA_FUNCS_delete

#define sk_CRYPTO_EX_DATA_FUNCS_delete	(		sk,
			where
	)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (where)))

sk_CRYPTO_EX_DATA_FUNCS_delete_ptr

#define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr	(		sk,
			p
	)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
      CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))

sk_CRYPTO_EX_DATA_FUNCS_dup

#define sk_CRYPTO_EX_DATA_FUNCS_dup

(

sk

)

Value:

((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_dup(CHECKED_CAST( \
      const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

sk_CRYPTO_EX_DATA_FUNCS_find

#define sk_CRYPTO_EX_DATA_FUNCS_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
          (out_index), CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))

sk_CRYPTO_EX_DATA_FUNCS_free

#define sk_CRYPTO_EX_DATA_FUNCS_free

(

sk

)

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

sk_CRYPTO_EX_DATA_FUNCS_insert

#define sk_CRYPTO_EX_DATA_FUNCS_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
            CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p), (where))

sk_CRYPTO_EX_DATA_FUNCS_is_sorted

#define sk_CRYPTO_EX_DATA_FUNCS_is_sorted

(

sk

)

Value:

sk_is_sorted(CHECKED_CAST(const _STACK *,   \
                            const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))

sk_CRYPTO_EX_DATA_FUNCS_new

#define sk_CRYPTO_EX_DATA_FUNCS_new

(

comp

)

Value:

((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new(CHECKED_CAST(                      \
      stack_cmp_func,                                                          \
      int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b), \
      comp)))

sk_CRYPTO_EX_DATA_FUNCS_new_null

#define sk_CRYPTO_EX_DATA_FUNCS_new_null

(

)

((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null())

sk_CRYPTO_EX_DATA_FUNCS_num

#define sk_CRYPTO_EX_DATA_FUNCS_num

(

sk

)

Value:

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \
                      sk))

sk_CRYPTO_EX_DATA_FUNCS_pop

#define sk_CRYPTO_EX_DATA_FUNCS_pop

(

sk

)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

sk_CRYPTO_EX_DATA_FUNCS_pop_free

#define sk_CRYPTO_EX_DATA_FUNCS_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *), \
                           free_func))

sk_CRYPTO_EX_DATA_FUNCS_push

#define sk_CRYPTO_EX_DATA_FUNCS_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \
          CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))

sk_CRYPTO_EX_DATA_FUNCS_set

#define sk_CRYPTO_EX_DATA_FUNCS_set	(		sk,
			i,
			p
	)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (i), \
      CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)))

sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func

#define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b)) \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk),     \
           CHECKED_CAST(stack_cmp_func,                                      \
                        int (*)(const CRYPTO_EX_DATA_FUNCS **a,              \
                                const CRYPTO_EX_DATA_FUNCS **b),             \
                        comp)))

sk_CRYPTO_EX_DATA_FUNCS_shift

#define sk_CRYPTO_EX_DATA_FUNCS_shift

(

sk

)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)))

sk_CRYPTO_EX_DATA_FUNCS_sort

#define sk_CRYPTO_EX_DATA_FUNCS_sort

(

sk

)

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

sk_CRYPTO_EX_DATA_FUNCS_value

#define sk_CRYPTO_EX_DATA_FUNCS_value	(		sk,
			i
	)

Value:

((CRYPTO_EX_DATA_FUNCS *)sk_value(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \
                   sk),                                                    \
      (i)))

sk_CRYPTO_EX_DATA_FUNCS_zero

#define sk_CRYPTO_EX_DATA_FUNCS_zero

(

sk

)

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

sk_DIST_POINT_deep_copy

#define sk_DIST_POINT_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(DIST_POINT) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk), \
      CHECKED_CAST(void *(*)(void *), DIST_POINT *(*)(DIST_POINT *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func)))

sk_DIST_POINT_delete

#define sk_DIST_POINT_delete	(		sk,
			where
	)

Value:

((DIST_POINT *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
                           (where)))

sk_DIST_POINT_delete_ptr

#define sk_DIST_POINT_delete_ptr	(		sk,
			p
	)

Value:

((DIST_POINT *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
      CHECKED_CAST(void *, DIST_POINT *, p)))

sk_DIST_POINT_dup

#define sk_DIST_POINT_dup

(

sk

)

Value:

((STACK_OF(DIST_POINT) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk)))

sk_DIST_POINT_find

#define sk_DIST_POINT_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), (out_index), \
          CHECKED_CAST(void *, DIST_POINT *, p))

sk_DIST_POINT_free

#define sk_DIST_POINT_free

(

sk

)

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

sk_DIST_POINT_insert

#define sk_DIST_POINT_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
            CHECKED_CAST(void *, DIST_POINT *, p), (where))

sk_DIST_POINT_is_sorted

#define sk_DIST_POINT_is_sorted

(

sk

)

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

sk_DIST_POINT_new

#define sk_DIST_POINT_new

(

comp

)

Value:

((STACK_OF(DIST_POINT) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const DIST_POINT **a, const DIST_POINT **b), \
      comp)))

sk_DIST_POINT_new_null

#define sk_DIST_POINT_new_null

(

)

((STACK_OF(DIST_POINT) *)sk_new_null())

sk_DIST_POINT_num

#define sk_DIST_POINT_num

(

sk

)

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

sk_DIST_POINT_pop

#define sk_DIST_POINT_pop

(

sk

)

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

sk_DIST_POINT_pop_free

#define sk_DIST_POINT_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func))

sk_DIST_POINT_push

#define sk_DIST_POINT_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
          CHECKED_CAST(void *, DIST_POINT *, p))

sk_DIST_POINT_set

#define sk_DIST_POINT_set	(		sk,
			i,
			p
	)

Value:

((DIST_POINT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \
                        (i), CHECKED_CAST(void *, DIST_POINT *, p)))

sk_DIST_POINT_set_cmp_func

#define sk_DIST_POINT_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const DIST_POINT **a, const DIST_POINT **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const DIST_POINT **a, const DIST_POINT **b),  \
                   comp)))

sk_DIST_POINT_shift

#define sk_DIST_POINT_shift

(

sk

)

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

sk_DIST_POINT_sort

#define sk_DIST_POINT_sort

(

sk

)

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

sk_DIST_POINT_value

#define sk_DIST_POINT_value	(		sk,
			i
	)

Value:

((DIST_POINT *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk), (i)))

sk_DIST_POINT_zero

#define sk_DIST_POINT_zero

(

sk

)

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

sk_GENERAL_NAME_deep_copy

#define sk_GENERAL_NAME_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(GENERAL_NAME) *)sk_deep_copy(                               \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk),  \
      CHECKED_CAST(void *(*)(void *), GENERAL_NAME *(*)(GENERAL_NAME *), \
                   copy_func),                                           \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func)))

sk_GENERAL_NAME_delete

#define sk_GENERAL_NAME_delete	(		sk,
			where
	)

Value:

((GENERAL_NAME *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (where)))

sk_GENERAL_NAME_delete_ptr

#define sk_GENERAL_NAME_delete_ptr	(		sk,
			p
	)

Value:

((GENERAL_NAME *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
      CHECKED_CAST(void *, GENERAL_NAME *, p)))

sk_GENERAL_NAME_dup

#define sk_GENERAL_NAME_dup

(

sk

)

Value:

((STACK_OF(GENERAL_NAME) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk)))

sk_GENERAL_NAME_find

#define sk_GENERAL_NAME_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (out_index), \
          CHECKED_CAST(void *, GENERAL_NAME *, p))

sk_GENERAL_NAME_free

#define sk_GENERAL_NAME_free

(

sk

)

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

sk_GENERAL_NAME_insert

#define sk_GENERAL_NAME_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
            CHECKED_CAST(void *, GENERAL_NAME *, p), (where))

sk_GENERAL_NAME_is_sorted

#define sk_GENERAL_NAME_is_sorted

(

sk

)

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

sk_GENERAL_NAME_new

#define sk_GENERAL_NAME_new

(

comp

)

Value:

((STACK_OF(GENERAL_NAME) *)sk_new(CHECKED_CAST(                              \
      stack_cmp_func, int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \
      comp)))

sk_GENERAL_NAME_new_null

#define sk_GENERAL_NAME_new_null

(

)

((STACK_OF(GENERAL_NAME) *)sk_new_null())

sk_GENERAL_NAME_num

#define sk_GENERAL_NAME_num

(

sk

)

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

sk_GENERAL_NAME_pop

#define sk_GENERAL_NAME_pop

(

sk

)

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

sk_GENERAL_NAME_pop_free

#define sk_GENERAL_NAME_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                              \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func))

sk_GENERAL_NAME_push

#define sk_GENERAL_NAME_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \
          CHECKED_CAST(void *, GENERAL_NAME *, p))

sk_GENERAL_NAME_set

#define sk_GENERAL_NAME_set	(		sk,
			i,
			p
	)

Value:

((GENERAL_NAME *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (i), \
      CHECKED_CAST(void *, GENERAL_NAME *, p)))

sk_GENERAL_NAME_set_cmp_func

#define sk_GENERAL_NAME_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk),                  \
      CHECKED_CAST(stack_cmp_func,                                           \
                   int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b),  \
                   comp)))

sk_GENERAL_NAME_shift

#define sk_GENERAL_NAME_shift

(

sk

)

Value:

((GENERAL_NAME *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)))

sk_GENERAL_NAME_sort

#define sk_GENERAL_NAME_sort

(

sk

)

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

sk_GENERAL_NAME_value

#define sk_GENERAL_NAME_value	(		sk,
			i
	)

Value:

((GENERAL_NAME *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk), (i)))

sk_GENERAL_NAME_zero

#define sk_GENERAL_NAME_zero

(

sk

)

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

sk_GENERAL_NAMES_deep_copy

#define sk_GENERAL_NAMES_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(GENERAL_NAMES) *)sk_deep_copy(                                \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk),   \
      CHECKED_CAST(void *(*)(void *), GENERAL_NAMES *(*)(GENERAL_NAMES *), \
                   copy_func),                                             \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func)))

sk_GENERAL_NAMES_delete

#define sk_GENERAL_NAMES_delete	(		sk,
			where
	)

Value:

((GENERAL_NAMES *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (where)))

sk_GENERAL_NAMES_delete_ptr

#define sk_GENERAL_NAMES_delete_ptr	(		sk,
			p
	)

Value:

((GENERAL_NAMES *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
      CHECKED_CAST(void *, GENERAL_NAMES *, p)))

sk_GENERAL_NAMES_dup

#define sk_GENERAL_NAMES_dup

(

sk

)

Value:

((STACK_OF(GENERAL_NAMES) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk)))

sk_GENERAL_NAMES_find

#define sk_GENERAL_NAMES_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (out_index), \
          CHECKED_CAST(void *, GENERAL_NAMES *, p))

sk_GENERAL_NAMES_free

#define sk_GENERAL_NAMES_free

(

sk

)

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

sk_GENERAL_NAMES_insert

#define sk_GENERAL_NAMES_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
            CHECKED_CAST(void *, GENERAL_NAMES *, p), (where))

sk_GENERAL_NAMES_is_sorted

#define sk_GENERAL_NAMES_is_sorted

(

sk

)

Value:

sk_is_sorted(                        \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk))

sk_GENERAL_NAMES_new

#define sk_GENERAL_NAMES_new

(

comp

)

Value:

((STACK_OF(GENERAL_NAMES) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                              \
      int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), comp)))

sk_GENERAL_NAMES_new_null

#define sk_GENERAL_NAMES_new_null

(

)

((STACK_OF(GENERAL_NAMES) *)sk_new_null())

sk_GENERAL_NAMES_num

#define sk_GENERAL_NAMES_num

(

sk

)

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

sk_GENERAL_NAMES_pop

#define sk_GENERAL_NAMES_pop

(

sk

)

Value:

((GENERAL_NAMES *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))

sk_GENERAL_NAMES_pop_free

#define sk_GENERAL_NAMES_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                               \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func))

sk_GENERAL_NAMES_push

#define sk_GENERAL_NAMES_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \
          CHECKED_CAST(void *, GENERAL_NAMES *, p))

sk_GENERAL_NAMES_set

#define sk_GENERAL_NAMES_set	(		sk,
			i,
			p
	)

Value:

((GENERAL_NAMES *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (i), \
      CHECKED_CAST(void *, GENERAL_NAMES *, p)))

sk_GENERAL_NAMES_set_cmp_func

#define sk_GENERAL_NAMES_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk),                   \
      CHECKED_CAST(stack_cmp_func,                                             \
                   int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b),  \
                   comp)))

sk_GENERAL_NAMES_shift

#define sk_GENERAL_NAMES_shift

(

sk

)

Value:

((GENERAL_NAMES *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)))

sk_GENERAL_NAMES_sort

#define sk_GENERAL_NAMES_sort

(

sk

)

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

sk_GENERAL_NAMES_value

#define sk_GENERAL_NAMES_value	(		sk,
			i
	)

Value:

((GENERAL_NAMES *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk), (i)))

sk_GENERAL_NAMES_zero

#define sk_GENERAL_NAMES_zero

(

sk

)

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

sk_GENERAL_SUBTREE_deep_copy

#define sk_GENERAL_SUBTREE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(GENERAL_SUBTREE) *)sk_deep_copy(                                  \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk),     \
      CHECKED_CAST(void *(*)(void *), GENERAL_SUBTREE *(*)(GENERAL_SUBTREE *), \
                   copy_func),                                                 \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func)))

sk_GENERAL_SUBTREE_delete

#define sk_GENERAL_SUBTREE_delete	(		sk,
			where
	)

Value:

((GENERAL_SUBTREE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (where)))

sk_GENERAL_SUBTREE_delete_ptr

#define sk_GENERAL_SUBTREE_delete_ptr	(		sk,
			p
	)

Value:

((GENERAL_SUBTREE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
      CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))

sk_GENERAL_SUBTREE_dup

#define sk_GENERAL_SUBTREE_dup

(

sk

)

Value:

((STACK_OF(GENERAL_SUBTREE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk)))

sk_GENERAL_SUBTREE_find

#define sk_GENERAL_SUBTREE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
          (out_index), CHECKED_CAST(void *, GENERAL_SUBTREE *, p))

sk_GENERAL_SUBTREE_free

#define sk_GENERAL_SUBTREE_free

(

sk

)

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

sk_GENERAL_SUBTREE_insert

#define sk_GENERAL_SUBTREE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
            CHECKED_CAST(void *, GENERAL_SUBTREE *, p), (where))

sk_GENERAL_SUBTREE_is_sorted

#define sk_GENERAL_SUBTREE_is_sorted

(

sk

)

Value:

sk_is_sorted(                          \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))

sk_GENERAL_SUBTREE_new

#define sk_GENERAL_SUBTREE_new

(

comp

)

Value:

((STACK_OF(GENERAL_SUBTREE) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                                \
      int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b), comp)))

sk_GENERAL_SUBTREE_new_null

#define sk_GENERAL_SUBTREE_new_null

(

)

((STACK_OF(GENERAL_SUBTREE) *)sk_new_null())

sk_GENERAL_SUBTREE_num

#define sk_GENERAL_SUBTREE_num

(

sk

)

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

sk_GENERAL_SUBTREE_pop

#define sk_GENERAL_SUBTREE_pop

(

sk

)

Value:

((GENERAL_SUBTREE *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))

sk_GENERAL_SUBTREE_pop_free

#define sk_GENERAL_SUBTREE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                 \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func))

sk_GENERAL_SUBTREE_push

#define sk_GENERAL_SUBTREE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \
          CHECKED_CAST(void *, GENERAL_SUBTREE *, p))

sk_GENERAL_SUBTREE_set

#define sk_GENERAL_SUBTREE_set	(		sk,
			i,
			p
	)

Value:

((GENERAL_SUBTREE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (i), \
      CHECKED_CAST(void *, GENERAL_SUBTREE *, p)))

sk_GENERAL_SUBTREE_set_cmp_func

#define sk_GENERAL_SUBTREE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b))          \
       sk_set_cmp_func(                                                     \
           CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const GENERAL_SUBTREE **a,  \
                                                const GENERAL_SUBTREE **b), \
                        comp)))

sk_GENERAL_SUBTREE_shift

#define sk_GENERAL_SUBTREE_shift

(

sk

)

Value:

((GENERAL_SUBTREE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)))

sk_GENERAL_SUBTREE_sort

#define sk_GENERAL_SUBTREE_sort

(

sk

)

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

sk_GENERAL_SUBTREE_value

#define sk_GENERAL_SUBTREE_value	(		sk,
			i
	)

Value:

((GENERAL_SUBTREE *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk), \
      (i)))

sk_GENERAL_SUBTREE_zero

#define sk_GENERAL_SUBTREE_zero

(

sk

)

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

sk_OPENSSL_STRING_deep_copy

#define sk_OPENSSL_STRING_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(OPENSSL_STRING) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \
      CHECKED_CAST(void *(*)(void *), OPENSSL_STRING (*)(OPENSSL_STRING), \
                   copy_func),                                            \
      CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func)))

sk_OPENSSL_STRING_delete

#define sk_OPENSSL_STRING_delete	(		sk,
			where
	)

Value:

((OPENSSL_STRING)sk_delete(               \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where)))

sk_OPENSSL_STRING_delete_ptr

#define sk_OPENSSL_STRING_delete_ptr	(		sk,
			p
	)

Value:

((OPENSSL_STRING)sk_delete_ptr(                             \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
      CHECKED_CAST(void *, OPENSSL_STRING, p)))

sk_OPENSSL_STRING_dup

#define sk_OPENSSL_STRING_dup

(

sk

)

Value:

((STACK_OF(OPENSSL_STRING) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk)))

sk_OPENSSL_STRING_find

#define sk_OPENSSL_STRING_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \
          CHECKED_CAST(void *, OPENSSL_STRING, p))

sk_OPENSSL_STRING_free

#define sk_OPENSSL_STRING_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

sk_OPENSSL_STRING_insert

#define sk_OPENSSL_STRING_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
            CHECKED_CAST(void *, OPENSSL_STRING, p), (where))

sk_OPENSSL_STRING_is_sorted

#define sk_OPENSSL_STRING_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

sk_OPENSSL_STRING_new

#define sk_OPENSSL_STRING_new

(

comp

)

Value:

((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp)))

sk_OPENSSL_STRING_new_null

#define sk_OPENSSL_STRING_new_null

(

)

((STACK_OF(OPENSSL_STRING) *)sk_new_null())

sk_OPENSSL_STRING_num

#define sk_OPENSSL_STRING_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))

sk_OPENSSL_STRING_pop

#define sk_OPENSSL_STRING_pop

(

sk

)

Value:

((OPENSSL_STRING)sk_pop(        \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

sk_OPENSSL_STRING_pop_free

#define sk_OPENSSL_STRING_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))

sk_OPENSSL_STRING_push

#define sk_OPENSSL_STRING_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \
          CHECKED_CAST(void *, OPENSSL_STRING, p))

sk_OPENSSL_STRING_set

#define sk_OPENSSL_STRING_set	(		sk,
			i,
			p
	)

Value:

((OPENSSL_STRING)sk_set(                                         \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \
      CHECKED_CAST(void *, OPENSSL_STRING, p)))

sk_OPENSSL_STRING_set_cmp_func

#define sk_OPENSSL_STRING_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a,  \
                                                const OPENSSL_STRING **b), \
                        comp)))

sk_OPENSSL_STRING_shift

#define sk_OPENSSL_STRING_shift

(

sk

)

Value:

((OPENSSL_STRING)sk_shift(        \
      CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)))

sk_OPENSSL_STRING_sort

#define sk_OPENSSL_STRING_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))

sk_OPENSSL_STRING_value

#define sk_OPENSSL_STRING_value	(		sk,
			i
	)

Value:

((OPENSSL_STRING)sk_value(                                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \
      (i)))

sk_OPENSSL_STRING_zero

#define sk_OPENSSL_STRING_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk));

sk_POLICY_MAPPING_deep_copy

#define sk_POLICY_MAPPING_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(POLICY_MAPPING) *)sk_deep_copy(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk),    \
      CHECKED_CAST(void *(*)(void *), POLICY_MAPPING *(*)(POLICY_MAPPING *), \
                   copy_func),                                               \
      CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func)))

sk_POLICY_MAPPING_delete

#define sk_POLICY_MAPPING_delete	(		sk,
			where
	)

Value:

((POLICY_MAPPING *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (where)))

sk_POLICY_MAPPING_delete_ptr

#define sk_POLICY_MAPPING_delete_ptr	(		sk,
			p
	)

Value:

((POLICY_MAPPING *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
      CHECKED_CAST(void *, POLICY_MAPPING *, p)))

sk_POLICY_MAPPING_dup

#define sk_POLICY_MAPPING_dup

(

sk

)

Value:

((STACK_OF(POLICY_MAPPING) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk)))

sk_POLICY_MAPPING_find

#define sk_POLICY_MAPPING_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (out_index), \
          CHECKED_CAST(void *, POLICY_MAPPING *, p))

sk_POLICY_MAPPING_free

#define sk_POLICY_MAPPING_free

(

sk

)

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

sk_POLICY_MAPPING_insert

#define sk_POLICY_MAPPING_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
            CHECKED_CAST(void *, POLICY_MAPPING *, p), (where))

sk_POLICY_MAPPING_is_sorted

#define sk_POLICY_MAPPING_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk))

sk_POLICY_MAPPING_new

#define sk_POLICY_MAPPING_new

(

comp

)

Value:

((STACK_OF(POLICY_MAPPING) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b), comp)))

sk_POLICY_MAPPING_new_null

#define sk_POLICY_MAPPING_new_null

(

)

((STACK_OF(POLICY_MAPPING) *)sk_new_null())

sk_POLICY_MAPPING_num

#define sk_POLICY_MAPPING_num

(

sk

)

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

sk_POLICY_MAPPING_pop

#define sk_POLICY_MAPPING_pop

(

sk

)

Value:

((POLICY_MAPPING *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))

sk_POLICY_MAPPING_pop_free

#define sk_POLICY_MAPPING_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func))

sk_POLICY_MAPPING_push

#define sk_POLICY_MAPPING_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \
          CHECKED_CAST(void *, POLICY_MAPPING *, p))

sk_POLICY_MAPPING_set

#define sk_POLICY_MAPPING_set	(		sk,
			i,
			p
	)

Value:

((POLICY_MAPPING *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (i), \
      CHECKED_CAST(void *, POLICY_MAPPING *, p)))

sk_POLICY_MAPPING_set_cmp_func

#define sk_POLICY_MAPPING_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const POLICY_MAPPING **a,  \
                                                const POLICY_MAPPING **b), \
                        comp)))

sk_POLICY_MAPPING_shift

#define sk_POLICY_MAPPING_shift

(

sk

)

Value:

((POLICY_MAPPING *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)))

sk_POLICY_MAPPING_sort

#define sk_POLICY_MAPPING_sort

(

sk

)

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

sk_POLICY_MAPPING_value

#define sk_POLICY_MAPPING_value	(		sk,
			i
	)

Value:

((POLICY_MAPPING *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk), \
      (i)))

sk_POLICY_MAPPING_zero

#define sk_POLICY_MAPPING_zero

(

sk

)

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

sk_POLICYINFO_deep_copy

#define sk_POLICYINFO_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(POLICYINFO) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk), \
      CHECKED_CAST(void *(*)(void *), POLICYINFO *(*)(POLICYINFO *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func)))

sk_POLICYINFO_delete

#define sk_POLICYINFO_delete	(		sk,
			where
	)

Value:

((POLICYINFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
                           (where)))

sk_POLICYINFO_delete_ptr

#define sk_POLICYINFO_delete_ptr	(		sk,
			p
	)

Value:

((POLICYINFO *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
      CHECKED_CAST(void *, POLICYINFO *, p)))

sk_POLICYINFO_dup

#define sk_POLICYINFO_dup

(

sk

)

Value:

((STACK_OF(POLICYINFO) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk)))

sk_POLICYINFO_find

#define sk_POLICYINFO_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), (out_index), \
          CHECKED_CAST(void *, POLICYINFO *, p))

sk_POLICYINFO_free

#define sk_POLICYINFO_free

(

sk

)

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

sk_POLICYINFO_insert

#define sk_POLICYINFO_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
            CHECKED_CAST(void *, POLICYINFO *, p), (where))

sk_POLICYINFO_is_sorted

#define sk_POLICYINFO_is_sorted

(

sk

)

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

sk_POLICYINFO_new

#define sk_POLICYINFO_new

(

comp

)

Value:

((STACK_OF(POLICYINFO) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const POLICYINFO **a, const POLICYINFO **b), \
      comp)))

sk_POLICYINFO_new_null

#define sk_POLICYINFO_new_null

(

)

((STACK_OF(POLICYINFO) *)sk_new_null())

sk_POLICYINFO_num

#define sk_POLICYINFO_num

(

sk

)

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

sk_POLICYINFO_pop

#define sk_POLICYINFO_pop

(

sk

)

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

sk_POLICYINFO_pop_free

#define sk_POLICYINFO_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func))

sk_POLICYINFO_push

#define sk_POLICYINFO_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
          CHECKED_CAST(void *, POLICYINFO *, p))

sk_POLICYINFO_set

#define sk_POLICYINFO_set	(		sk,
			i,
			p
	)

Value:

((POLICYINFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \
                        (i), CHECKED_CAST(void *, POLICYINFO *, p)))

sk_POLICYINFO_set_cmp_func

#define sk_POLICYINFO_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const POLICYINFO **a, const POLICYINFO **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const POLICYINFO **a, const POLICYINFO **b),  \
                   comp)))

sk_POLICYINFO_shift

#define sk_POLICYINFO_shift

(

sk

)

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

sk_POLICYINFO_sort

#define sk_POLICYINFO_sort

(

sk

)

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

sk_POLICYINFO_value

#define sk_POLICYINFO_value	(		sk,
			i
	)

Value:

((POLICYINFO *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk), (i)))

sk_POLICYINFO_zero

#define sk_POLICYINFO_zero

(

sk

)

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

sk_POLICYQUALINFO_deep_copy

#define sk_POLICYQUALINFO_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(POLICYQUALINFO) *)sk_deep_copy(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk),    \
      CHECKED_CAST(void *(*)(void *), POLICYQUALINFO *(*)(POLICYQUALINFO *), \
                   copy_func),                                               \
      CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func)))

sk_POLICYQUALINFO_delete

#define sk_POLICYQUALINFO_delete	(		sk,
			where
	)

Value:

((POLICYQUALINFO *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (where)))

sk_POLICYQUALINFO_delete_ptr

#define sk_POLICYQUALINFO_delete_ptr	(		sk,
			p
	)

Value:

((POLICYQUALINFO *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
      CHECKED_CAST(void *, POLICYQUALINFO *, p)))

sk_POLICYQUALINFO_dup

#define sk_POLICYQUALINFO_dup

(

sk

)

Value:

((STACK_OF(POLICYQUALINFO) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk)))

sk_POLICYQUALINFO_find

#define sk_POLICYQUALINFO_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (out_index), \
          CHECKED_CAST(void *, POLICYQUALINFO *, p))

sk_POLICYQUALINFO_free

#define sk_POLICYQUALINFO_free

(

sk

)

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

sk_POLICYQUALINFO_insert

#define sk_POLICYQUALINFO_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
            CHECKED_CAST(void *, POLICYQUALINFO *, p), (where))

sk_POLICYQUALINFO_is_sorted

#define sk_POLICYQUALINFO_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk))

sk_POLICYQUALINFO_new

#define sk_POLICYQUALINFO_new

(

comp

)

Value:

((STACK_OF(POLICYQUALINFO) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b), comp)))

sk_POLICYQUALINFO_new_null

#define sk_POLICYQUALINFO_new_null

(

)

((STACK_OF(POLICYQUALINFO) *)sk_new_null())

sk_POLICYQUALINFO_num

#define sk_POLICYQUALINFO_num

(

sk

)

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

sk_POLICYQUALINFO_pop

#define sk_POLICYQUALINFO_pop

(

sk

)

Value:

((POLICYQUALINFO *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))

sk_POLICYQUALINFO_pop_free

#define sk_POLICYQUALINFO_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func))

sk_POLICYQUALINFO_push

#define sk_POLICYQUALINFO_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \
          CHECKED_CAST(void *, POLICYQUALINFO *, p))

sk_POLICYQUALINFO_set

#define sk_POLICYQUALINFO_set	(		sk,
			i,
			p
	)

Value:

((POLICYQUALINFO *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (i), \
      CHECKED_CAST(void *, POLICYQUALINFO *, p)))

sk_POLICYQUALINFO_set_cmp_func

#define sk_POLICYQUALINFO_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const POLICYQUALINFO **a,  \
                                                const POLICYQUALINFO **b), \
                        comp)))

sk_POLICYQUALINFO_shift

#define sk_POLICYQUALINFO_shift

(

sk

)

Value:

((POLICYQUALINFO *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)))

sk_POLICYQUALINFO_sort

#define sk_POLICYQUALINFO_sort

(

sk

)

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

sk_POLICYQUALINFO_value

#define sk_POLICYQUALINFO_value	(		sk,
			i
	)

Value:

((POLICYQUALINFO *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk), \
      (i)))

sk_POLICYQUALINFO_zero

#define sk_POLICYQUALINFO_zero

(

sk

)

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

sk_RSA_additional_prime_deep_copy

#define sk_RSA_additional_prime_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(RSA_additional_prime) *)sk_deep_copy(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \
                   sk),                                                    \
      CHECKED_CAST(void *(*)(void *),                                      \
                   RSA_additional_prime *(*)(RSA_additional_prime *),      \
                   copy_func),                                             \
      CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *),     \
                   free_func)))

sk_RSA_additional_prime_delete

#define sk_RSA_additional_prime_delete	(		sk,
			where
	)

Value:

((RSA_additional_prime *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (where)))

sk_RSA_additional_prime_delete_ptr

#define sk_RSA_additional_prime_delete_ptr	(		sk,
			p
	)

Value:

((RSA_additional_prime *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \
      CHECKED_CAST(void *, RSA_additional_prime *, p)))

sk_RSA_additional_prime_dup

#define sk_RSA_additional_prime_dup

(

sk

)

Value:

((STACK_OF(RSA_additional_prime) *)sk_dup(CHECKED_CAST( \
      const _STACK *, const STACK_OF(RSA_additional_prime) *, sk)))

sk_RSA_additional_prime_find

#define sk_RSA_additional_prime_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \
          (out_index), CHECKED_CAST(void *, RSA_additional_prime *, p))

sk_RSA_additional_prime_free

#define sk_RSA_additional_prime_free

(

sk

)

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

sk_RSA_additional_prime_insert

#define sk_RSA_additional_prime_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \
            CHECKED_CAST(void *, RSA_additional_prime *, p), (where))

sk_RSA_additional_prime_is_sorted

#define sk_RSA_additional_prime_is_sorted

(

sk

)

Value:

sk_is_sorted(CHECKED_CAST(const _STACK *,   \
                            const STACK_OF(RSA_additional_prime) *, sk))

sk_RSA_additional_prime_new

#define sk_RSA_additional_prime_new

(

comp

)

Value:

((STACK_OF(RSA_additional_prime) *)sk_new(CHECKED_CAST(                      \
      stack_cmp_func,                                                          \
      int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b), \
      comp)))

sk_RSA_additional_prime_new_null

#define sk_RSA_additional_prime_new_null

(

)

((STACK_OF(RSA_additional_prime) *)sk_new_null())

sk_RSA_additional_prime_num

#define sk_RSA_additional_prime_num

(

sk

)

Value:

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \
                      sk))

sk_RSA_additional_prime_pop

#define sk_RSA_additional_prime_pop

(

sk

)

Value:

((RSA_additional_prime *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)))

sk_RSA_additional_prime_pop_free

#define sk_RSA_additional_prime_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *), \
                           free_func))

sk_RSA_additional_prime_push

#define sk_RSA_additional_prime_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \
          CHECKED_CAST(void *, RSA_additional_prime *, p))

sk_RSA_additional_prime_set

#define sk_RSA_additional_prime_set	(		sk,
			i,
			p
	)

Value:

((RSA_additional_prime *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (i), \
      CHECKED_CAST(void *, RSA_additional_prime *, p)))

sk_RSA_additional_prime_set_cmp_func

#define sk_RSA_additional_prime_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b)) \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk),     \
           CHECKED_CAST(stack_cmp_func,                                      \
                        int (*)(const RSA_additional_prime **a,              \
                                const RSA_additional_prime **b),             \
                        comp)))

sk_RSA_additional_prime_shift

#define sk_RSA_additional_prime_shift

(

sk

)

Value:

((RSA_additional_prime *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)))

sk_RSA_additional_prime_sort

#define sk_RSA_additional_prime_sort

(

sk

)

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

sk_RSA_additional_prime_value

#define sk_RSA_additional_prime_value	(		sk,
			i
	)

Value:

((RSA_additional_prime *)sk_value(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \
                   sk),                                                    \
      (i)))

sk_RSA_additional_prime_zero

#define sk_RSA_additional_prime_zero

(

sk

)

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

sk_SRTP_PROTECTION_PROFILE_deep_copy

#define sk_SRTP_PROTECTION_PROFILE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_deep_copy(                          \
      CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *,  \
                   sk),                                                        \
      CHECKED_CAST(                                                            \
          void *(*)(void *),                                                   \
          const SRTP_PROTECTION_PROFILE *(*)(const SRTP_PROTECTION_PROFILE *), \
          copy_func),                                                          \
      CHECKED_CAST(void (*)(void *),                                           \
                   void (*)(const SRTP_PROTECTION_PROFILE *), free_func)))

sk_SRTP_PROTECTION_PROFILE_delete

#define sk_SRTP_PROTECTION_PROFILE_delete	(		sk,
			where
	)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_delete(                         \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
      (where)))

sk_SRTP_PROTECTION_PROFILE_delete_ptr

#define sk_SRTP_PROTECTION_PROFILE_delete_ptr	(		sk,
			p
	)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr(                     \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
      CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

sk_SRTP_PROTECTION_PROFILE_dup

#define sk_SRTP_PROTECTION_PROFILE_dup

(

sk

)

Value:

((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup(CHECKED_CAST( \
      const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

sk_SRTP_PROTECTION_PROFILE_find

#define sk_SRTP_PROTECTION_PROFILE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
          (out_index),                                                     \
          CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

sk_SRTP_PROTECTION_PROFILE_free

#define sk_SRTP_PROTECTION_PROFILE_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

sk_SRTP_PROTECTION_PROFILE_insert

#define sk_SRTP_PROTECTION_PROFILE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
            CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where))

sk_SRTP_PROTECTION_PROFILE_is_sorted

#define sk_SRTP_PROTECTION_PROFILE_is_sorted

(

sk

)

Value:

sk_is_sorted(CHECKED_CAST(const _STACK *,      \
                            const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

sk_SRTP_PROTECTION_PROFILE_new

#define sk_SRTP_PROTECTION_PROFILE_new

(

comp

)

Value:

((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST(            \
      stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a,  \
                              const const SRTP_PROTECTION_PROFILE **b), \
      comp)))

sk_SRTP_PROTECTION_PROFILE_new_null

#define sk_SRTP_PROTECTION_PROFILE_new_null

(

)

((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null())

sk_SRTP_PROTECTION_PROFILE_num

#define sk_SRTP_PROTECTION_PROFILE_num

(

sk

)

Value:

sk_num(CHECKED_CAST(const _STACK *,      \
                      const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

sk_SRTP_PROTECTION_PROFILE_pop

#define sk_SRTP_PROTECTION_PROFILE_pop

(

sk

)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_pop( \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

sk_SRTP_PROTECTION_PROFILE_pop_free

#define sk_SRTP_PROTECTION_PROFILE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                         \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
      CHECKED_CAST(void (*)(void *),                                   \
                   void (*)(const SRTP_PROTECTION_PROFILE *), free_func))

sk_SRTP_PROTECTION_PROFILE_push

#define sk_SRTP_PROTECTION_PROFILE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
          CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))

sk_SRTP_PROTECTION_PROFILE_set

#define sk_SRTP_PROTECTION_PROFILE_set	(		sk,
			i,
			p
	)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_set(                                 \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \
      CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)))

sk_SRTP_PROTECTION_PROFILE_set_cmp_func

#define sk_SRTP_PROTECTION_PROFILE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const SRTP_PROTECTION_PROFILE **a,                              \
            const SRTP_PROTECTION_PROFILE **b))                             \
       sk_set_cmp_func(                                                     \
           CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \
           CHECKED_CAST(stack_cmp_func,                                     \
                        int (*)(const SRTP_PROTECTION_PROFILE **a,          \
                                const SRTP_PROTECTION_PROFILE **b),         \
                        comp)))

sk_SRTP_PROTECTION_PROFILE_shift

#define sk_SRTP_PROTECTION_PROFILE_shift

(

sk

)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_shift( \
      CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)))

sk_SRTP_PROTECTION_PROFILE_sort

#define sk_SRTP_PROTECTION_PROFILE_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))

sk_SRTP_PROTECTION_PROFILE_value

#define sk_SRTP_PROTECTION_PROFILE_value	(		sk,
			i
	)

Value:

((const SRTP_PROTECTION_PROFILE *)sk_value(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \
                   sk),                                                       \
      (i)))

sk_SRTP_PROTECTION_PROFILE_zero

#define sk_SRTP_PROTECTION_PROFILE_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk));

sk_SSL_CIPHER_deep_copy

#define sk_SSL_CIPHER_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(SSL_CIPHER) *)sk_deep_copy(                                  \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk),     \
      CHECKED_CAST(void *(*)(void *),                                     \
                   const SSL_CIPHER *(*)(const SSL_CIPHER *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *),        \
                   free_func)))

sk_SSL_CIPHER_delete

#define sk_SSL_CIPHER_delete	(		sk,
			where
	)

Value:

((const SSL_CIPHER *)sk_delete(       \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where)))

sk_SSL_CIPHER_delete_ptr

#define sk_SSL_CIPHER_delete_ptr	(		sk,
			p
	)

Value:

((const SSL_CIPHER *)sk_delete_ptr(                     \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
      CHECKED_CAST(void *, const SSL_CIPHER *, p)))

sk_SSL_CIPHER_dup

#define sk_SSL_CIPHER_dup

(

sk

)

Value:

((STACK_OF(SSL_CIPHER) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk)))

sk_SSL_CIPHER_find

#define sk_SSL_CIPHER_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \
          CHECKED_CAST(void *, const SSL_CIPHER *, p))

sk_SSL_CIPHER_free

#define sk_SSL_CIPHER_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

sk_SSL_CIPHER_insert

#define sk_SSL_CIPHER_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
            CHECKED_CAST(void *, const SSL_CIPHER *, p), (where))

sk_SSL_CIPHER_is_sorted

#define sk_SSL_CIPHER_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))

sk_SSL_CIPHER_new

#define sk_SSL_CIPHER_new

(

comp

)

Value:

((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                           \
      int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp)))

sk_SSL_CIPHER_new_null

#define sk_SSL_CIPHER_new_null

(

)

((STACK_OF(SSL_CIPHER) *)sk_new_null())

sk_SSL_CIPHER_num

#define sk_SSL_CIPHER_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))

sk_SSL_CIPHER_pop

#define sk_SSL_CIPHER_pop

(

sk

)

Value:

((const SSL_CIPHER *)sk_pop( \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

sk_SSL_CIPHER_pop_free

#define sk_SSL_CIPHER_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func))

sk_SSL_CIPHER_push

#define sk_SSL_CIPHER_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \
          CHECKED_CAST(void *, const SSL_CIPHER *, p))

sk_SSL_CIPHER_set

#define sk_SSL_CIPHER_set	(		sk,
			i,
			p
	)

Value:

((const SSL_CIPHER *)sk_set(                                 \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \
      CHECKED_CAST(void *, const SSL_CIPHER *, p)))

sk_SSL_CIPHER_set_cmp_func

#define sk_SSL_CIPHER_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b),  \
                   comp)))

sk_SSL_CIPHER_shift

#define sk_SSL_CIPHER_shift

(

sk

)

Value:

((const SSL_CIPHER *)sk_shift( \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)))

sk_SSL_CIPHER_sort

#define sk_SSL_CIPHER_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))

sk_SSL_CIPHER_value

#define sk_SSL_CIPHER_value	(		sk,
			i
	)

Value:

((const SSL_CIPHER *)sk_value(   \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i)))

sk_SSL_CIPHER_zero

#define sk_SSL_CIPHER_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk));

sk_SSL_COMP_deep_copy

#define sk_SSL_COMP_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(SSL_COMP) *)sk_deep_copy(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk),          \
      CHECKED_CAST(void *(*)(void *), SSL_COMP *(*)(SSL_COMP *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func)))

sk_SSL_COMP_delete

#define sk_SSL_COMP_delete	(		sk,
			where
	)

Value:

((SSL_COMP *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
                         (where)))

sk_SSL_COMP_delete_ptr

#define sk_SSL_COMP_delete_ptr	(		sk,
			p
	)

Value:

((SSL_COMP *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
                             CHECKED_CAST(void *, SSL_COMP *, p)))

sk_SSL_COMP_dup

#define sk_SSL_COMP_dup

(

sk

)

Value:

((STACK_OF(SSL_COMP) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk)))

sk_SSL_COMP_find

#define sk_SSL_COMP_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (out_index), \
          CHECKED_CAST(void *, SSL_COMP *, p))

sk_SSL_COMP_free

#define sk_SSL_COMP_free

(

sk

)

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

sk_SSL_COMP_insert

#define sk_SSL_COMP_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
            CHECKED_CAST(void *, SSL_COMP *, p), (where))

sk_SSL_COMP_is_sorted

#define sk_SSL_COMP_is_sorted

(

sk

)

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

sk_SSL_COMP_new

#define sk_SSL_COMP_new

(

comp

)

Value:

((STACK_OF(SSL_COMP) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))

sk_SSL_COMP_new_null

#define sk_SSL_COMP_new_null

(

)

((STACK_OF(SSL_COMP) *)sk_new_null())

sk_SSL_COMP_num

#define sk_SSL_COMP_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk))

sk_SSL_COMP_pop

#define sk_SSL_COMP_pop

(

sk

)

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

sk_SSL_COMP_pop_free

#define sk_SSL_COMP_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func))

sk_SSL_COMP_push

#define sk_SSL_COMP_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \
          CHECKED_CAST(void *, SSL_COMP *, p))

sk_SSL_COMP_set

#define sk_SSL_COMP_set	(		sk,
			i,
			p
	)

Value:

((SSL_COMP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (i), \
                      CHECKED_CAST(void *, SSL_COMP *, p)))

sk_SSL_COMP_set_cmp_func

#define sk_SSL_COMP_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const SSL_COMP **a, const SSL_COMP **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk),              \
      CHECKED_CAST(stack_cmp_func,                                   \
                   int (*)(const SSL_COMP **a, const SSL_COMP **b), comp)))

sk_SSL_COMP_shift

#define sk_SSL_COMP_shift

(

sk

)

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

sk_SSL_COMP_sort

#define sk_SSL_COMP_sort

(

sk

)

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

sk_SSL_COMP_value

#define sk_SSL_COMP_value	(		sk,
			i
	)

Value:

((SSL_COMP *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk), (i)))

sk_SSL_COMP_zero

#define sk_SSL_COMP_zero

(

sk

)

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

sk_SSL_CUSTOM_EXTENSION_deep_copy

#define sk_SSL_CUSTOM_EXTENSION_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_deep_copy(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \
                   sk),                                                    \
      CHECKED_CAST(void *(*)(void *),                                      \
                   SSL_CUSTOM_EXTENSION *(*)(SSL_CUSTOM_EXTENSION *),      \
                   copy_func),                                             \
      CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *),     \
                   free_func)))

sk_SSL_CUSTOM_EXTENSION_delete

#define sk_SSL_CUSTOM_EXTENSION_delete	(		sk,
			where
	)

Value:

((SSL_CUSTOM_EXTENSION *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (where)))

sk_SSL_CUSTOM_EXTENSION_delete_ptr

#define sk_SSL_CUSTOM_EXTENSION_delete_ptr	(		sk,
			p
	)

Value:

((SSL_CUSTOM_EXTENSION *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \
      CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

sk_SSL_CUSTOM_EXTENSION_dup

#define sk_SSL_CUSTOM_EXTENSION_dup

(

sk

)

Value:

((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_dup(CHECKED_CAST( \
      const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

sk_SSL_CUSTOM_EXTENSION_find

#define sk_SSL_CUSTOM_EXTENSION_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \
          (out_index), CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

sk_SSL_CUSTOM_EXTENSION_free

#define sk_SSL_CUSTOM_EXTENSION_free

(

sk

)

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

sk_SSL_CUSTOM_EXTENSION_insert

#define sk_SSL_CUSTOM_EXTENSION_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \
            CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p), (where))

sk_SSL_CUSTOM_EXTENSION_is_sorted

#define sk_SSL_CUSTOM_EXTENSION_is_sorted

(

sk

)

Value:

sk_is_sorted(CHECKED_CAST(const _STACK *,   \
                            const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))

sk_SSL_CUSTOM_EXTENSION_new

#define sk_SSL_CUSTOM_EXTENSION_new

(

comp

)

Value:

((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new(CHECKED_CAST(                      \
      stack_cmp_func,                                                          \
      int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b), \
      comp)))

sk_SSL_CUSTOM_EXTENSION_new_null

#define sk_SSL_CUSTOM_EXTENSION_new_null

(

)

((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null())

sk_SSL_CUSTOM_EXTENSION_num

#define sk_SSL_CUSTOM_EXTENSION_num

(

sk

)

Value:

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \
                      sk))

sk_SSL_CUSTOM_EXTENSION_pop

#define sk_SSL_CUSTOM_EXTENSION_pop

(

sk

)

Value:

((SSL_CUSTOM_EXTENSION *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

sk_SSL_CUSTOM_EXTENSION_pop_free

#define sk_SSL_CUSTOM_EXTENSION_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \
                           free_func))

sk_SSL_CUSTOM_EXTENSION_push

#define sk_SSL_CUSTOM_EXTENSION_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \
          CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))

sk_SSL_CUSTOM_EXTENSION_set

#define sk_SSL_CUSTOM_EXTENSION_set	(		sk,
			i,
			p
	)

Value:

((SSL_CUSTOM_EXTENSION *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (i), \
      CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)))

sk_SSL_CUSTOM_EXTENSION_set_cmp_func

#define sk_SSL_CUSTOM_EXTENSION_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b)) \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk),     \
           CHECKED_CAST(stack_cmp_func,                                      \
                        int (*)(const SSL_CUSTOM_EXTENSION **a,              \
                                const SSL_CUSTOM_EXTENSION **b),             \
                        comp)))

sk_SSL_CUSTOM_EXTENSION_shift

#define sk_SSL_CUSTOM_EXTENSION_shift

(

sk

)

Value:

((SSL_CUSTOM_EXTENSION *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)))

sk_SSL_CUSTOM_EXTENSION_sort

#define sk_SSL_CUSTOM_EXTENSION_sort

(

sk

)

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

sk_SSL_CUSTOM_EXTENSION_value

#define sk_SSL_CUSTOM_EXTENSION_value	(		sk,
			i
	)

Value:

((SSL_CUSTOM_EXTENSION *)sk_value(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \
                   sk),                                                    \
      (i)))

sk_SSL_CUSTOM_EXTENSION_zero

#define sk_SSL_CUSTOM_EXTENSION_zero

(

sk

)

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

sk_STACK_OF_X509_NAME_ENTRY_deep_copy

#define sk_STACK_OF_X509_NAME_ENTRY_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_deep_copy(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \
                   sk),                                                        \
      CHECKED_CAST(void *(*)(void *),                                          \
                   STACK_OF_X509_NAME_ENTRY *(*)(STACK_OF_X509_NAME_ENTRY *),  \
                   copy_func),                                                 \
      CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *),     \
                   free_func)))

sk_STACK_OF_X509_NAME_ENTRY_delete

#define sk_STACK_OF_X509_NAME_ENTRY_delete	(		sk,
			where
	)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_delete(                               \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
      (where)))

sk_STACK_OF_X509_NAME_ENTRY_delete_ptr

#define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr	(		sk,
			p
	)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
      CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

sk_STACK_OF_X509_NAME_ENTRY_dup

#define sk_STACK_OF_X509_NAME_ENTRY_dup

(

sk

)

Value:

((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup(CHECKED_CAST( \
      const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

sk_STACK_OF_X509_NAME_ENTRY_find

#define sk_STACK_OF_X509_NAME_ENTRY_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
          (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

sk_STACK_OF_X509_NAME_ENTRY_free

#define sk_STACK_OF_X509_NAME_ENTRY_free

(

sk

)

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

sk_STACK_OF_X509_NAME_ENTRY_insert

#define sk_STACK_OF_X509_NAME_ENTRY_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
            CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where))

sk_STACK_OF_X509_NAME_ENTRY_is_sorted

#define sk_STACK_OF_X509_NAME_ENTRY_is_sorted

(

sk

)

Value:

sk_is_sorted(CHECKED_CAST(const _STACK *,       \
                            const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

sk_STACK_OF_X509_NAME_ENTRY_new

#define sk_STACK_OF_X509_NAME_ENTRY_new

(

comp

)

Value:

((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST(      \
      stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a,  \
                              const STACK_OF_X509_NAME_ENTRY **b), \
      comp)))

sk_STACK_OF_X509_NAME_ENTRY_new_null

#define sk_STACK_OF_X509_NAME_ENTRY_new_null

(

)

((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null())

sk_STACK_OF_X509_NAME_ENTRY_num

#define sk_STACK_OF_X509_NAME_ENTRY_num

(

sk

)

Value:

sk_num(CHECKED_CAST(const _STACK *,       \
                      const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))

sk_STACK_OF_X509_NAME_ENTRY_pop

#define sk_STACK_OF_X509_NAME_ENTRY_pop

(

sk

)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

sk_STACK_OF_X509_NAME_ENTRY_pop_free

#define sk_STACK_OF_X509_NAME_ENTRY_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                             \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk),    \
      CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \
                   free_func))

sk_STACK_OF_X509_NAME_ENTRY_push

#define sk_STACK_OF_X509_NAME_ENTRY_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
          CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))

sk_STACK_OF_X509_NAME_ENTRY_set

#define sk_STACK_OF_X509_NAME_ENTRY_set	(		sk,
			i,
			p
	)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \
      CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)))

sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func

#define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const STACK_OF_X509_NAME_ENTRY **a,                              \
            const STACK_OF_X509_NAME_ENTRY **b))                             \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \
           CHECKED_CAST(stack_cmp_func,                                      \
                        int (*)(const STACK_OF_X509_NAME_ENTRY **a,          \
                                const STACK_OF_X509_NAME_ENTRY **b),         \
                        comp)))

sk_STACK_OF_X509_NAME_ENTRY_shift

#define sk_STACK_OF_X509_NAME_ENTRY_shift

(

sk

)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)))

sk_STACK_OF_X509_NAME_ENTRY_sort

#define sk_STACK_OF_X509_NAME_ENTRY_sort

(

sk

)

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

sk_STACK_OF_X509_NAME_ENTRY_value

#define sk_STACK_OF_X509_NAME_ENTRY_value	(		sk,
			i
	)

Value:

((STACK_OF_X509_NAME_ENTRY *)sk_value(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \
                   sk),                                                        \
      (i)))

sk_STACK_OF_X509_NAME_ENTRY_zero

#define sk_STACK_OF_X509_NAME_ENTRY_zero

(

sk

)

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

sk_SXNETID_deep_copy

#define sk_SXNETID_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(SXNETID) *)sk_deep_copy(                                      \
      CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk),         \
      CHECKED_CAST(void *(*)(void *), SXNETID *(*)(SXNETID *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func)))

sk_SXNETID_delete

#define sk_SXNETID_delete	(		sk,
			where
	)

Value:

((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
                        (where)))

sk_SXNETID_delete_ptr

#define sk_SXNETID_delete_ptr	(		sk,
			p
	)

Value:

((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
                            CHECKED_CAST(void *, SXNETID *, p)))

sk_SXNETID_dup

#define sk_SXNETID_dup

(

sk

)

Value:

((STACK_OF(SXNETID) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk)))

sk_SXNETID_find

#define sk_SXNETID_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \
          CHECKED_CAST(void *, SXNETID *, p))

sk_SXNETID_free

#define sk_SXNETID_free

(

sk

)

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

sk_SXNETID_insert

#define sk_SXNETID_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
            CHECKED_CAST(void *, SXNETID *, p), (where))

sk_SXNETID_is_sorted

#define sk_SXNETID_is_sorted

(

sk

)

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

sk_SXNETID_new

#define sk_SXNETID_new

(

comp

)

Value:

((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp)))

sk_SXNETID_new_null

#define sk_SXNETID_new_null

(

)

((STACK_OF(SXNETID) *)sk_new_null())

sk_SXNETID_num

#define sk_SXNETID_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))

sk_SXNETID_pop

#define sk_SXNETID_pop

(

sk

)

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

sk_SXNETID_pop_free

#define sk_SXNETID_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))

sk_SXNETID_push

#define sk_SXNETID_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \
          CHECKED_CAST(void *, SXNETID *, p))

sk_SXNETID_set

#define sk_SXNETID_set	(		sk,
			i,
			p
	)

Value:

((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \
                     CHECKED_CAST(void *, SXNETID *, p)))

sk_SXNETID_set_cmp_func

#define sk_SXNETID_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk),             \
      CHECKED_CAST(stack_cmp_func,                                 \
                   int (*)(const SXNETID **a, const SXNETID **b), comp)))

sk_SXNETID_shift

#define sk_SXNETID_shift

(

sk

)

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

sk_SXNETID_sort

#define sk_SXNETID_sort

(

sk

)

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

sk_SXNETID_value

#define sk_SXNETID_value	(		sk,
			i
	)

Value:

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

sk_SXNETID_zero

#define sk_SXNETID_zero

(

sk

)

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

sk_void_deep_copy

#define sk_void_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(void) *)sk_deep_copy(                                   \
      CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk),      \
      CHECKED_CAST(void *(*)(void *), void *(*)(void *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(void *), free_func)))

sk_void_delete

#define sk_void_delete	(		sk,
			where
	)		((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (where)))

sk_void_delete_ptr

#define sk_void_delete_ptr	(		sk,
			p
	)

Value:

((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \
                         CHECKED_CAST(void *, void *, p)))

sk_void_dup

#define sk_void_dup

(

sk

)

Value:

((STACK_OF(void) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk)))

sk_void_find

#define sk_void_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (out_index), \
          CHECKED_CAST(void *, void *, p))

sk_void_free

#define sk_void_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

sk_void_insert

#define sk_void_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \
            CHECKED_CAST(void *, void *, p), (where))

sk_void_is_sorted

#define sk_void_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))

sk_void_new

#define sk_void_new

(

comp

)

Value:

((STACK_OF(void) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const void **a, const void **b), comp)))

sk_void_new_null

#define sk_void_new_null

(

)

((STACK_OF(void) *)sk_new_null())

sk_void_num

#define sk_void_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))

sk_void_pop

#define sk_void_pop

(

sk

)

((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))

sk_void_pop_free

#define sk_void_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))

sk_void_push

#define sk_void_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \
          CHECKED_CAST(void *, void *, p))

sk_void_set

#define sk_void_set	(		sk,
			i,
			p
	)

Value:

((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (i), \
                  CHECKED_CAST(void *, void *, p)))

sk_void_set_cmp_func

#define sk_void_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const void **a, const void **b))sk_set_cmp_func(                \
      CHECKED_CAST(_STACK *, STACK_OF(void) *, sk),                         \
      CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \
                   comp)))

sk_void_shift

#define sk_void_shift

(

sk

)

((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)))

sk_void_sort

#define sk_void_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))

sk_void_value

#define sk_void_value	(		sk,
			i
	)

Value:

((void *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk), \
                    (i)))

sk_void_zero

#define sk_void_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk));

sk_X509_ALGOR_deep_copy

#define sk_X509_ALGOR_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_ALGOR) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), \
      CHECKED_CAST(void *(*)(void *), X509_ALGOR *(*)(X509_ALGOR *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func)))

sk_X509_ALGOR_delete

#define sk_X509_ALGOR_delete	(		sk,
			where
	)

Value:

((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
                           (where)))

sk_X509_ALGOR_delete_ptr

#define sk_X509_ALGOR_delete_ptr	(		sk,
			p
	)

Value:

((X509_ALGOR *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
      CHECKED_CAST(void *, X509_ALGOR *, p)))

sk_X509_ALGOR_dup

#define sk_X509_ALGOR_dup

(

sk

)

Value:

((STACK_OF(X509_ALGOR) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk)))

sk_X509_ALGOR_find

#define sk_X509_ALGOR_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_ALGOR *, p))

sk_X509_ALGOR_free

#define sk_X509_ALGOR_free

(

sk

)

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

sk_X509_ALGOR_insert

#define sk_X509_ALGOR_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
            CHECKED_CAST(void *, X509_ALGOR *, p), (where))

sk_X509_ALGOR_is_sorted

#define sk_X509_ALGOR_is_sorted

(

sk

)

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

sk_X509_ALGOR_new

#define sk_X509_ALGOR_new

(

comp

)

Value:

((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \
      comp)))

sk_X509_ALGOR_new_null

#define sk_X509_ALGOR_new_null

(

)

((STACK_OF(X509_ALGOR) *)sk_new_null())

sk_X509_ALGOR_num

#define sk_X509_ALGOR_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))

sk_X509_ALGOR_pop

#define sk_X509_ALGOR_pop

(

sk

)

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

sk_X509_ALGOR_pop_free

#define sk_X509_ALGOR_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))

sk_X509_ALGOR_push

#define sk_X509_ALGOR_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
          CHECKED_CAST(void *, X509_ALGOR *, p))

sk_X509_ALGOR_set

#define sk_X509_ALGOR_set	(		sk,
			i,
			p
	)

Value:

((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \
                        (i), CHECKED_CAST(void *, X509_ALGOR *, p)))

sk_X509_ALGOR_set_cmp_func

#define sk_X509_ALGOR_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const X509_ALGOR **a, const X509_ALGOR **b),  \
                   comp)))

sk_X509_ALGOR_shift

#define sk_X509_ALGOR_shift

(

sk

)

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

sk_X509_ALGOR_sort

#define sk_X509_ALGOR_sort

(

sk

)

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

sk_X509_ALGOR_value

#define sk_X509_ALGOR_value	(		sk,
			i
	)

Value:

((X509_ALGOR *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), (i)))

sk_X509_ALGOR_zero

#define sk_X509_ALGOR_zero

(

sk

)

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

sk_X509_ATTRIBUTE_deep_copy

#define sk_X509_ATTRIBUTE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_ATTRIBUTE) *)sk_deep_copy(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk),    \
      CHECKED_CAST(void *(*)(void *), X509_ATTRIBUTE *(*)(X509_ATTRIBUTE *), \
                   copy_func),                                               \
      CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func)))

sk_X509_ATTRIBUTE_delete

#define sk_X509_ATTRIBUTE_delete	(		sk,
			where
	)

Value:

((X509_ATTRIBUTE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where)))

sk_X509_ATTRIBUTE_delete_ptr

#define sk_X509_ATTRIBUTE_delete_ptr	(		sk,
			p
	)

Value:

((X509_ATTRIBUTE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
      CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

sk_X509_ATTRIBUTE_dup

#define sk_X509_ATTRIBUTE_dup

(

sk

)

Value:

((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)))

sk_X509_ATTRIBUTE_find

#define sk_X509_ATTRIBUTE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

sk_X509_ATTRIBUTE_free

#define sk_X509_ATTRIBUTE_free

(

sk

)

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

sk_X509_ATTRIBUTE_insert

#define sk_X509_ATTRIBUTE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
            CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where))

sk_X509_ATTRIBUTE_is_sorted

#define sk_X509_ATTRIBUTE_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

sk_X509_ATTRIBUTE_new

#define sk_X509_ATTRIBUTE_new

(

comp

)

Value:

((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp)))

sk_X509_ATTRIBUTE_new_null

#define sk_X509_ATTRIBUTE_new_null

(

)

((STACK_OF(X509_ATTRIBUTE) *)sk_new_null())

sk_X509_ATTRIBUTE_num

#define sk_X509_ATTRIBUTE_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))

sk_X509_ATTRIBUTE_pop

#define sk_X509_ATTRIBUTE_pop

(

sk

)

Value:

((X509_ATTRIBUTE *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

sk_X509_ATTRIBUTE_pop_free

#define sk_X509_ATTRIBUTE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))

sk_X509_ATTRIBUTE_push

#define sk_X509_ATTRIBUTE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \
          CHECKED_CAST(void *, X509_ATTRIBUTE *, p))

sk_X509_ATTRIBUTE_set

#define sk_X509_ATTRIBUTE_set	(		sk,
			i,
			p
	)

Value:

((X509_ATTRIBUTE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \
      CHECKED_CAST(void *, X509_ATTRIBUTE *, p)))

sk_X509_ATTRIBUTE_set_cmp_func

#define sk_X509_ATTRIBUTE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a,  \
                                                const X509_ATTRIBUTE **b), \
                        comp)))

sk_X509_ATTRIBUTE_shift

#define sk_X509_ATTRIBUTE_shift

(

sk

)

Value:

((X509_ATTRIBUTE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)))

sk_X509_ATTRIBUTE_sort

#define sk_X509_ATTRIBUTE_sort

(

sk

)

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

sk_X509_ATTRIBUTE_value

#define sk_X509_ATTRIBUTE_value	(		sk,
			i
	)

Value:

((X509_ATTRIBUTE *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), \
      (i)))

sk_X509_ATTRIBUTE_zero

#define sk_X509_ATTRIBUTE_zero

(

sk

)

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

sk_X509_CRL_deep_copy

#define sk_X509_CRL_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_CRL) *)sk_deep_copy(                                       \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk),          \
      CHECKED_CAST(void *(*)(void *), X509_CRL *(*)(X509_CRL *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func)))

sk_X509_CRL_delete

#define sk_X509_CRL_delete	(		sk,
			where
	)

Value:

((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
                         (where)))

sk_X509_CRL_delete_ptr

#define sk_X509_CRL_delete_ptr	(		sk,
			p
	)

Value:

((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
                             CHECKED_CAST(void *, X509_CRL *, p)))

sk_X509_CRL_dup

#define sk_X509_CRL_dup

(

sk

)

Value:

((STACK_OF(X509_CRL) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk)))

sk_X509_CRL_find

#define sk_X509_CRL_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_CRL *, p))

sk_X509_CRL_free

#define sk_X509_CRL_free

(

sk

)

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

sk_X509_CRL_insert

#define sk_X509_CRL_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
            CHECKED_CAST(void *, X509_CRL *, p), (where))

sk_X509_CRL_is_sorted

#define sk_X509_CRL_is_sorted

(

sk

)

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

sk_X509_CRL_new

#define sk_X509_CRL_new

(

comp

)

Value:

((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

sk_X509_CRL_new_null

#define sk_X509_CRL_new_null

(

)

((STACK_OF(X509_CRL) *)sk_new_null())

sk_X509_CRL_num

#define sk_X509_CRL_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))

sk_X509_CRL_pop

#define sk_X509_CRL_pop

(

sk

)

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

sk_X509_CRL_pop_free

#define sk_X509_CRL_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))

sk_X509_CRL_push

#define sk_X509_CRL_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \
          CHECKED_CAST(void *, X509_CRL *, p))

sk_X509_CRL_set

#define sk_X509_CRL_set	(		sk,
			i,
			p
	)

Value:

((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \
                      CHECKED_CAST(void *, X509_CRL *, p)))

sk_X509_CRL_set_cmp_func

#define sk_X509_CRL_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk),              \
      CHECKED_CAST(stack_cmp_func,                                   \
                   int (*)(const X509_CRL **a, const X509_CRL **b), comp)))

sk_X509_CRL_shift

#define sk_X509_CRL_shift

(

sk

)

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

sk_X509_CRL_sort

#define sk_X509_CRL_sort

(

sk

)

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

sk_X509_CRL_value

#define sk_X509_CRL_value	(		sk,
			i
	)

Value:

((X509_CRL *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk), (i)))

sk_X509_CRL_zero

#define sk_X509_CRL_zero

(

sk

)

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

sk_X509_deep_copy

#define sk_X509_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509) *)sk_deep_copy(                                   \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk),      \
      CHECKED_CAST(void *(*)(void *), X509 *(*)(X509 *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func)))

sk_X509_delete

#define sk_X509_delete	(		sk,
			where
	)		((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where)))

sk_X509_delete_ptr

#define sk_X509_delete_ptr	(		sk,
			p
	)

Value:

((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
                         CHECKED_CAST(void *, X509 *, p)))

sk_X509_dup

#define sk_X509_dup

(

sk

)

Value:

((STACK_OF(X509) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk)))

sk_X509_EXTENSION_deep_copy

#define sk_X509_EXTENSION_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_EXTENSION) *)sk_deep_copy(                                 \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk),    \
      CHECKED_CAST(void *(*)(void *), X509_EXTENSION *(*)(X509_EXTENSION *), \
                   copy_func),                                               \
      CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func)))

sk_X509_EXTENSION_delete

#define sk_X509_EXTENSION_delete	(		sk,
			where
	)

Value:

((X509_EXTENSION *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where)))

sk_X509_EXTENSION_delete_ptr

#define sk_X509_EXTENSION_delete_ptr	(		sk,
			p
	)

Value:

((X509_EXTENSION *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
      CHECKED_CAST(void *, X509_EXTENSION *, p)))

sk_X509_EXTENSION_dup

#define sk_X509_EXTENSION_dup

(

sk

)

Value:

((STACK_OF(X509_EXTENSION) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk)))

sk_X509_EXTENSION_find

#define sk_X509_EXTENSION_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_EXTENSION *, p))

sk_X509_EXTENSION_free

#define sk_X509_EXTENSION_free

(

sk

)

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

sk_X509_EXTENSION_insert

#define sk_X509_EXTENSION_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
            CHECKED_CAST(void *, X509_EXTENSION *, p), (where))

sk_X509_EXTENSION_is_sorted

#define sk_X509_EXTENSION_is_sorted

(

sk

)

Value:

sk_is_sorted(                         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))

sk_X509_EXTENSION_new

#define sk_X509_EXTENSION_new

(

comp

)

Value:

((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                               \
      int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp)))

sk_X509_EXTENSION_new_null

#define sk_X509_EXTENSION_new_null

(

)

((STACK_OF(X509_EXTENSION) *)sk_new_null())

sk_X509_EXTENSION_num

#define sk_X509_EXTENSION_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))

sk_X509_EXTENSION_pop

#define sk_X509_EXTENSION_pop

(

sk

)

Value:

((X509_EXTENSION *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

sk_X509_EXTENSION_pop_free

#define sk_X509_EXTENSION_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))

sk_X509_EXTENSION_push

#define sk_X509_EXTENSION_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \
          CHECKED_CAST(void *, X509_EXTENSION *, p))

sk_X509_EXTENSION_set

#define sk_X509_EXTENSION_set	(		sk,
			i,
			p
	)

Value:

((X509_EXTENSION *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \
      CHECKED_CAST(void *, X509_EXTENSION *, p)))

sk_X509_EXTENSION_set_cmp_func

#define sk_X509_EXTENSION_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b))           \
       sk_set_cmp_func(                                                    \
           CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a,  \
                                                const X509_EXTENSION **b), \
                        comp)))

sk_X509_EXTENSION_shift

#define sk_X509_EXTENSION_shift

(

sk

)

Value:

((X509_EXTENSION *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)))

sk_X509_EXTENSION_sort

#define sk_X509_EXTENSION_sort

(

sk

)

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

sk_X509_EXTENSION_value

#define sk_X509_EXTENSION_value	(		sk,
			i
	)

Value:

((X509_EXTENSION *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk), \
      (i)))

sk_X509_EXTENSION_zero

#define sk_X509_EXTENSION_zero

(

sk

)

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

sk_X509_find

#define sk_X509_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \
          CHECKED_CAST(void *, X509 *, p))

sk_X509_free

#define sk_X509_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

sk_X509_INFO_deep_copy

#define sk_X509_INFO_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_INFO) *)sk_deep_copy(                                        \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk),           \
      CHECKED_CAST(void *(*)(void *), X509_INFO *(*)(X509_INFO *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func)))

sk_X509_INFO_delete

#define sk_X509_INFO_delete	(		sk,
			where
	)

Value:

((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
                          (where)))

sk_X509_INFO_delete_ptr

#define sk_X509_INFO_delete_ptr	(		sk,
			p
	)

Value:

((X509_INFO *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
      CHECKED_CAST(void *, X509_INFO *, p)))

sk_X509_INFO_dup

#define sk_X509_INFO_dup

(

sk

)

Value:

((STACK_OF(X509_INFO) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk)))

sk_X509_INFO_find

#define sk_X509_INFO_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_INFO *, p))

sk_X509_INFO_free

#define sk_X509_INFO_free

(

sk

)

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

sk_X509_INFO_insert

#define sk_X509_INFO_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
            CHECKED_CAST(void *, X509_INFO *, p), (where))

sk_X509_INFO_is_sorted

#define sk_X509_INFO_is_sorted

(

sk

)

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

sk_X509_INFO_new

#define sk_X509_INFO_new

(

comp

)

Value:

((STACK_OF(X509_INFO) *)sk_new(  \
      CHECKED_CAST(stack_cmp_func, \
                   int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

sk_X509_INFO_new_null

#define sk_X509_INFO_new_null

(

)

((STACK_OF(X509_INFO) *)sk_new_null())

sk_X509_INFO_num

#define sk_X509_INFO_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))

sk_X509_INFO_pop

#define sk_X509_INFO_pop

(

sk

)

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

sk_X509_INFO_pop_free

#define sk_X509_INFO_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))

sk_X509_INFO_push

#define sk_X509_INFO_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \
          CHECKED_CAST(void *, X509_INFO *, p))

sk_X509_INFO_set

#define sk_X509_INFO_set	(		sk,
			i,
			p
	)

Value:

((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \
                       CHECKED_CAST(void *, X509_INFO *, p)))

sk_X509_INFO_set_cmp_func

#define sk_X509_INFO_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk),               \
      CHECKED_CAST(stack_cmp_func,                                     \
                   int (*)(const X509_INFO **a, const X509_INFO **b), comp)))

sk_X509_INFO_shift

#define sk_X509_INFO_shift

(

sk

)

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

sk_X509_INFO_sort

#define sk_X509_INFO_sort

(

sk

)

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

sk_X509_INFO_value

#define sk_X509_INFO_value	(		sk,
			i
	)

Value:

((X509_INFO *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk), (i)))

sk_X509_INFO_zero

#define sk_X509_INFO_zero

(

sk

)

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

sk_X509_insert

#define sk_X509_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
            CHECKED_CAST(void *, X509 *, p), (where))

sk_X509_is_sorted

#define sk_X509_is_sorted

(

sk

)

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

sk_X509_LOOKUP_deep_copy

#define sk_X509_LOOKUP_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_LOOKUP) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), \
      CHECKED_CAST(void *(*)(void *), X509_LOOKUP *(*)(X509_LOOKUP *), \
                   copy_func),                                         \
      CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func)))

sk_X509_LOOKUP_delete

#define sk_X509_LOOKUP_delete	(		sk,
			where
	)

Value:

((X509_LOOKUP *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where)))

sk_X509_LOOKUP_delete_ptr

#define sk_X509_LOOKUP_delete_ptr	(		sk,
			p
	)

Value:

((X509_LOOKUP *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
      CHECKED_CAST(void *, X509_LOOKUP *, p)))

sk_X509_LOOKUP_dup

#define sk_X509_LOOKUP_dup

(

sk

)

Value:

((STACK_OF(X509_LOOKUP) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk)))

sk_X509_LOOKUP_find

#define sk_X509_LOOKUP_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_LOOKUP *, p))

sk_X509_LOOKUP_free

#define sk_X509_LOOKUP_free

(

sk

)

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

sk_X509_LOOKUP_insert

#define sk_X509_LOOKUP_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
            CHECKED_CAST(void *, X509_LOOKUP *, p), (where))

sk_X509_LOOKUP_is_sorted

#define sk_X509_LOOKUP_is_sorted

(

sk

)

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

sk_X509_LOOKUP_new

#define sk_X509_LOOKUP_new

(

comp

)

Value:

((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST(                             \
      stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \
      comp)))

sk_X509_LOOKUP_new_null

#define sk_X509_LOOKUP_new_null

(

)

((STACK_OF(X509_LOOKUP) *)sk_new_null())

sk_X509_LOOKUP_num

#define sk_X509_LOOKUP_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))

sk_X509_LOOKUP_pop

#define sk_X509_LOOKUP_pop

(

sk

)

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

sk_X509_LOOKUP_pop_free

#define sk_X509_LOOKUP_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))

sk_X509_LOOKUP_push

#define sk_X509_LOOKUP_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
          CHECKED_CAST(void *, X509_LOOKUP *, p))

sk_X509_LOOKUP_set

#define sk_X509_LOOKUP_set	(		sk,
			i,
			p
	)

Value:

((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \
                         (i), CHECKED_CAST(void *, X509_LOOKUP *, p)))

sk_X509_LOOKUP_set_cmp_func

#define sk_X509_LOOKUP_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk),                 \
      CHECKED_CAST(stack_cmp_func,                                         \
                   int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b),  \
                   comp)))

sk_X509_LOOKUP_shift

#define sk_X509_LOOKUP_shift

(

sk

)

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

sk_X509_LOOKUP_sort

#define sk_X509_LOOKUP_sort

(

sk

)

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

sk_X509_LOOKUP_value

#define sk_X509_LOOKUP_value	(		sk,
			i
	)

Value:

((X509_LOOKUP *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i)))

sk_X509_LOOKUP_zero

#define sk_X509_LOOKUP_zero

(

sk

)

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

sk_X509_NAME_deep_copy

#define sk_X509_NAME_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_NAME) *)sk_deep_copy(                                        \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk),           \
      CHECKED_CAST(void *(*)(void *), X509_NAME *(*)(X509_NAME *), copy_func), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func)))

sk_X509_NAME_delete

#define sk_X509_NAME_delete	(		sk,
			where
	)

Value:

((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
                          (where)))

sk_X509_NAME_delete_ptr

#define sk_X509_NAME_delete_ptr	(		sk,
			p
	)

Value:

((X509_NAME *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
      CHECKED_CAST(void *, X509_NAME *, p)))

sk_X509_NAME_dup

#define sk_X509_NAME_dup

(

sk

)

Value:

((STACK_OF(X509_NAME) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk)))

sk_X509_NAME_ENTRY_deep_copy

#define sk_X509_NAME_ENTRY_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_NAME_ENTRY) *)sk_deep_copy(                                  \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk),     \
      CHECKED_CAST(void *(*)(void *), X509_NAME_ENTRY *(*)(X509_NAME_ENTRY *), \
                   copy_func),                                                 \
      CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func)))

sk_X509_NAME_ENTRY_delete

#define sk_X509_NAME_ENTRY_delete	(		sk,
			where
	)

Value:

((X509_NAME_ENTRY *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where)))

sk_X509_NAME_ENTRY_delete_ptr

#define sk_X509_NAME_ENTRY_delete_ptr	(		sk,
			p
	)

Value:

((X509_NAME_ENTRY *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
      CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

sk_X509_NAME_ENTRY_dup

#define sk_X509_NAME_ENTRY_dup

(

sk

)

Value:

((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)))

sk_X509_NAME_ENTRY_find

#define sk_X509_NAME_ENTRY_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
          (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

sk_X509_NAME_ENTRY_free

#define sk_X509_NAME_ENTRY_free

(

sk

)

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

sk_X509_NAME_ENTRY_insert

#define sk_X509_NAME_ENTRY_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
            CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where))

sk_X509_NAME_ENTRY_is_sorted

#define sk_X509_NAME_ENTRY_is_sorted

(

sk

)

Value:

sk_is_sorted(                          \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

sk_X509_NAME_ENTRY_new

#define sk_X509_NAME_ENTRY_new

(

comp

)

Value:

((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                                \
      int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp)))

sk_X509_NAME_ENTRY_new_null

#define sk_X509_NAME_ENTRY_new_null

(

)

((STACK_OF(X509_NAME_ENTRY) *)sk_new_null())

sk_X509_NAME_ENTRY_num

#define sk_X509_NAME_ENTRY_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))

sk_X509_NAME_ENTRY_pop

#define sk_X509_NAME_ENTRY_pop

(

sk

)

Value:

((X509_NAME_ENTRY *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

sk_X509_NAME_ENTRY_pop_free

#define sk_X509_NAME_ENTRY_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                 \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))

sk_X509_NAME_ENTRY_push

#define sk_X509_NAME_ENTRY_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \
          CHECKED_CAST(void *, X509_NAME_ENTRY *, p))

sk_X509_NAME_ENTRY_set

#define sk_X509_NAME_ENTRY_set	(		sk,
			i,
			p
	)

Value:

((X509_NAME_ENTRY *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \
      CHECKED_CAST(void *, X509_NAME_ENTRY *, p)))

sk_X509_NAME_ENTRY_set_cmp_func

#define sk_X509_NAME_ENTRY_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b))          \
       sk_set_cmp_func(                                                     \
           CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a,  \
                                                const X509_NAME_ENTRY **b), \
                        comp)))

sk_X509_NAME_ENTRY_shift

#define sk_X509_NAME_ENTRY_shift

(

sk

)

Value:

((X509_NAME_ENTRY *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)))

sk_X509_NAME_ENTRY_sort

#define sk_X509_NAME_ENTRY_sort

(

sk

)

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

sk_X509_NAME_ENTRY_value

#define sk_X509_NAME_ENTRY_value	(		sk,
			i
	)

Value:

((X509_NAME_ENTRY *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), \
      (i)))

sk_X509_NAME_ENTRY_zero

#define sk_X509_NAME_ENTRY_zero

(

sk

)

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

sk_X509_NAME_find

#define sk_X509_NAME_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_NAME *, p))

sk_X509_NAME_free

#define sk_X509_NAME_free

(

sk

)

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

sk_X509_NAME_insert

#define sk_X509_NAME_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
            CHECKED_CAST(void *, X509_NAME *, p), (where))

sk_X509_NAME_is_sorted

#define sk_X509_NAME_is_sorted

(

sk

)

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

sk_X509_NAME_new

#define sk_X509_NAME_new

(

comp

)

Value:

((STACK_OF(X509_NAME) *)sk_new(  \
      CHECKED_CAST(stack_cmp_func, \
                   int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

sk_X509_NAME_new_null

#define sk_X509_NAME_new_null

(

)

((STACK_OF(X509_NAME) *)sk_new_null())

sk_X509_NAME_num

#define sk_X509_NAME_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))

sk_X509_NAME_pop

#define sk_X509_NAME_pop

(

sk

)

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

sk_X509_NAME_pop_free

#define sk_X509_NAME_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))

sk_X509_NAME_push

#define sk_X509_NAME_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \
          CHECKED_CAST(void *, X509_NAME *, p))

sk_X509_NAME_set

#define sk_X509_NAME_set	(		sk,
			i,
			p
	)

Value:

((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \
                       CHECKED_CAST(void *, X509_NAME *, p)))

sk_X509_NAME_set_cmp_func

#define sk_X509_NAME_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk),               \
      CHECKED_CAST(stack_cmp_func,                                     \
                   int (*)(const X509_NAME **a, const X509_NAME **b), comp)))

sk_X509_NAME_shift

#define sk_X509_NAME_shift

(

sk

)

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

sk_X509_NAME_sort

#define sk_X509_NAME_sort

(

sk

)

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

sk_X509_NAME_value

#define sk_X509_NAME_value	(		sk,
			i
	)

Value:

((X509_NAME *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk), (i)))

sk_X509_NAME_zero

#define sk_X509_NAME_zero

(

sk

)

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

sk_X509_new

#define sk_X509_new

(

comp

)

Value:

((STACK_OF(X509) *)sk_new(CHECKED_CAST( \
      stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp)))

sk_X509_new_null

#define sk_X509_new_null

(

)

((STACK_OF(X509) *)sk_new_null())

sk_X509_num

#define sk_X509_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))

sk_X509_OBJECT_deep_copy

#define sk_X509_OBJECT_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_OBJECT) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), \
      CHECKED_CAST(void *(*)(void *), X509_OBJECT *(*)(X509_OBJECT *), \
                   copy_func),                                         \
      CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func)))

sk_X509_OBJECT_delete

#define sk_X509_OBJECT_delete	(		sk,
			where
	)

Value:

((X509_OBJECT *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where)))

sk_X509_OBJECT_delete_ptr

#define sk_X509_OBJECT_delete_ptr	(		sk,
			p
	)

Value:

((X509_OBJECT *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
      CHECKED_CAST(void *, X509_OBJECT *, p)))

sk_X509_OBJECT_dup

#define sk_X509_OBJECT_dup

(

sk

)

Value:

((STACK_OF(X509_OBJECT) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk)))

sk_X509_OBJECT_find

#define sk_X509_OBJECT_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_OBJECT *, p))

sk_X509_OBJECT_free

#define sk_X509_OBJECT_free

(

sk

)

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

sk_X509_OBJECT_insert

#define sk_X509_OBJECT_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
            CHECKED_CAST(void *, X509_OBJECT *, p), (where))

sk_X509_OBJECT_is_sorted

#define sk_X509_OBJECT_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))

sk_X509_OBJECT_new

#define sk_X509_OBJECT_new

(

comp

)

Value:

((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST(                             \
      stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \
      comp)))

sk_X509_OBJECT_new_null

#define sk_X509_OBJECT_new_null

(

)

((STACK_OF(X509_OBJECT) *)sk_new_null())

sk_X509_OBJECT_num

#define sk_X509_OBJECT_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))

sk_X509_OBJECT_pop

#define sk_X509_OBJECT_pop

(

sk

)

((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

sk_X509_OBJECT_pop_free

#define sk_X509_OBJECT_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))

sk_X509_OBJECT_push

#define sk_X509_OBJECT_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
          CHECKED_CAST(void *, X509_OBJECT *, p))

sk_X509_OBJECT_set

#define sk_X509_OBJECT_set	(		sk,
			i,
			p
	)

Value:

((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \
                         (i), CHECKED_CAST(void *, X509_OBJECT *, p)))

sk_X509_OBJECT_set_cmp_func

#define sk_X509_OBJECT_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk),                 \
      CHECKED_CAST(stack_cmp_func,                                         \
                   int (*)(const X509_OBJECT **a, const X509_OBJECT **b),  \
                   comp)))

sk_X509_OBJECT_shift

#define sk_X509_OBJECT_shift

(

sk

)

((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)))

sk_X509_OBJECT_sort

#define sk_X509_OBJECT_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))

sk_X509_OBJECT_value

#define sk_X509_OBJECT_value	(		sk,
			i
	)

Value:

((X509_OBJECT *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), (i)))

sk_X509_OBJECT_zero

#define sk_X509_OBJECT_zero

(

sk

)

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

sk_X509_POLICY_DATA_deep_copy

#define sk_X509_POLICY_DATA_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_POLICY_DATA) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                       \
                   X509_POLICY_DATA *(*)(X509_POLICY_DATA *), copy_func),   \
      CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *),          \
                   free_func)))

sk_X509_POLICY_DATA_delete

#define sk_X509_POLICY_DATA_delete	(		sk,
			where
	)

Value:

((X509_POLICY_DATA *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where)))

sk_X509_POLICY_DATA_delete_ptr

#define sk_X509_POLICY_DATA_delete_ptr	(		sk,
			p
	)

Value:

((X509_POLICY_DATA *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
      CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

sk_X509_POLICY_DATA_dup

#define sk_X509_POLICY_DATA_dup

(

sk

)

Value:

((STACK_OF(X509_POLICY_DATA) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)))

sk_X509_POLICY_DATA_find

#define sk_X509_POLICY_DATA_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
          (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p))

sk_X509_POLICY_DATA_free

#define sk_X509_POLICY_DATA_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

sk_X509_POLICY_DATA_insert

#define sk_X509_POLICY_DATA_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
            CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where))

sk_X509_POLICY_DATA_is_sorted

#define sk_X509_POLICY_DATA_is_sorted

(

sk

)

Value:

sk_is_sorted(                           \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

sk_X509_POLICY_DATA_new

#define sk_X509_POLICY_DATA_new

(

comp

)

Value:

((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                                 \
      int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp)))

sk_X509_POLICY_DATA_new_null

#define sk_X509_POLICY_DATA_new_null

(

)

((STACK_OF(X509_POLICY_DATA) *)sk_new_null())

sk_X509_POLICY_DATA_num

#define sk_X509_POLICY_DATA_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))

sk_X509_POLICY_DATA_pop

#define sk_X509_POLICY_DATA_pop

(

sk

)

Value:

((X509_POLICY_DATA *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

sk_X509_POLICY_DATA_pop_free

#define sk_X509_POLICY_DATA_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                  \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func))

sk_X509_POLICY_DATA_push

#define sk_X509_POLICY_DATA_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \
          CHECKED_CAST(void *, X509_POLICY_DATA *, p))

sk_X509_POLICY_DATA_set

#define sk_X509_POLICY_DATA_set	(		sk,
			i,
			p
	)

Value:

((X509_POLICY_DATA *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \
      CHECKED_CAST(void *, X509_POLICY_DATA *, p)))

sk_X509_POLICY_DATA_set_cmp_func

#define sk_X509_POLICY_DATA_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b))         \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a,  \
                                                const X509_POLICY_DATA **b), \
                        comp)))

sk_X509_POLICY_DATA_shift

#define sk_X509_POLICY_DATA_shift

(

sk

)

Value:

((X509_POLICY_DATA *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)))

sk_X509_POLICY_DATA_sort

#define sk_X509_POLICY_DATA_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))

sk_X509_POLICY_DATA_value

#define sk_X509_POLICY_DATA_value	(		sk,
			i
	)

Value:

((X509_POLICY_DATA *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \
      (i)))

sk_X509_POLICY_DATA_zero

#define sk_X509_POLICY_DATA_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk));

sk_X509_POLICY_NODE_deep_copy

#define sk_X509_POLICY_NODE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_POLICY_NODE) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                       \
                   X509_POLICY_NODE *(*)(X509_POLICY_NODE *), copy_func),   \
      CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *),          \
                   free_func)))

sk_X509_POLICY_NODE_delete

#define sk_X509_POLICY_NODE_delete	(		sk,
			where
	)

Value:

((X509_POLICY_NODE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where)))

sk_X509_POLICY_NODE_delete_ptr

#define sk_X509_POLICY_NODE_delete_ptr	(		sk,
			p
	)

Value:

((X509_POLICY_NODE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
      CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

sk_X509_POLICY_NODE_dup

#define sk_X509_POLICY_NODE_dup

(

sk

)

Value:

((STACK_OF(X509_POLICY_NODE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)))

sk_X509_POLICY_NODE_find

#define sk_X509_POLICY_NODE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
          (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p))

sk_X509_POLICY_NODE_free

#define sk_X509_POLICY_NODE_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

sk_X509_POLICY_NODE_insert

#define sk_X509_POLICY_NODE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
            CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where))

sk_X509_POLICY_NODE_is_sorted

#define sk_X509_POLICY_NODE_is_sorted

(

sk

)

Value:

sk_is_sorted(                           \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

sk_X509_POLICY_NODE_new

#define sk_X509_POLICY_NODE_new

(

comp

)

Value:

((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \
      stack_cmp_func,                                 \
      int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp)))

sk_X509_POLICY_NODE_new_null

#define sk_X509_POLICY_NODE_new_null

(

)

((STACK_OF(X509_POLICY_NODE) *)sk_new_null())

sk_X509_POLICY_NODE_num

#define sk_X509_POLICY_NODE_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))

sk_X509_POLICY_NODE_pop

#define sk_X509_POLICY_NODE_pop

(

sk

)

Value:

((X509_POLICY_NODE *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

sk_X509_POLICY_NODE_pop_free

#define sk_X509_POLICY_NODE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                                  \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func))

sk_X509_POLICY_NODE_push

#define sk_X509_POLICY_NODE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \
          CHECKED_CAST(void *, X509_POLICY_NODE *, p))

sk_X509_POLICY_NODE_set

#define sk_X509_POLICY_NODE_set	(		sk,
			i,
			p
	)

Value:

((X509_POLICY_NODE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \
      CHECKED_CAST(void *, X509_POLICY_NODE *, p)))

sk_X509_POLICY_NODE_set_cmp_func

#define sk_X509_POLICY_NODE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b))         \
       sk_set_cmp_func(                                                      \
           CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a,  \
                                                const X509_POLICY_NODE **b), \
                        comp)))

sk_X509_POLICY_NODE_shift

#define sk_X509_POLICY_NODE_shift

(

sk

)

Value:

((X509_POLICY_NODE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)))

sk_X509_POLICY_NODE_sort

#define sk_X509_POLICY_NODE_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))

sk_X509_POLICY_NODE_value

#define sk_X509_POLICY_NODE_value	(		sk,
			i
	)

Value:

((X509_POLICY_NODE *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \
      (i)))

sk_X509_POLICY_NODE_zero

#define sk_X509_POLICY_NODE_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk));

sk_X509_pop

#define sk_X509_pop

(

sk

)

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

sk_X509_pop_free

#define sk_X509_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
              CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))

sk_X509_PURPOSE_deep_copy

#define sk_X509_PURPOSE_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_PURPOSE) *)sk_deep_copy(                               \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk),  \
      CHECKED_CAST(void *(*)(void *), X509_PURPOSE *(*)(X509_PURPOSE *), \
                   copy_func),                                           \
      CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func)))

sk_X509_PURPOSE_delete

#define sk_X509_PURPOSE_delete	(		sk,
			where
	)

Value:

((X509_PURPOSE *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where)))

sk_X509_PURPOSE_delete_ptr

#define sk_X509_PURPOSE_delete_ptr	(		sk,
			p
	)

Value:

((X509_PURPOSE *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
      CHECKED_CAST(void *, X509_PURPOSE *, p)))

sk_X509_PURPOSE_dup

#define sk_X509_PURPOSE_dup

(

sk

)

Value:

((STACK_OF(X509_PURPOSE) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk)))

sk_X509_PURPOSE_find

#define sk_X509_PURPOSE_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_PURPOSE *, p))

sk_X509_PURPOSE_free

#define sk_X509_PURPOSE_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

sk_X509_PURPOSE_insert

#define sk_X509_PURPOSE_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
            CHECKED_CAST(void *, X509_PURPOSE *, p), (where))

sk_X509_PURPOSE_is_sorted

#define sk_X509_PURPOSE_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))

sk_X509_PURPOSE_new

#define sk_X509_PURPOSE_new

(

comp

)

Value:

((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST(                              \
      stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \
      comp)))

sk_X509_PURPOSE_new_null

#define sk_X509_PURPOSE_new_null

(

)

((STACK_OF(X509_PURPOSE) *)sk_new_null())

sk_X509_PURPOSE_num

#define sk_X509_PURPOSE_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))

sk_X509_PURPOSE_pop

#define sk_X509_PURPOSE_pop

(

sk

)

((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

sk_X509_PURPOSE_pop_free

#define sk_X509_PURPOSE_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                              \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))

sk_X509_PURPOSE_push

#define sk_X509_PURPOSE_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \
          CHECKED_CAST(void *, X509_PURPOSE *, p))

sk_X509_PURPOSE_set

#define sk_X509_PURPOSE_set	(		sk,
			i,
			p
	)

Value:

((X509_PURPOSE *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \
      CHECKED_CAST(void *, X509_PURPOSE *, p)))

sk_X509_PURPOSE_set_cmp_func

#define sk_X509_PURPOSE_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk),                  \
      CHECKED_CAST(stack_cmp_func,                                           \
                   int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b),  \
                   comp)))

sk_X509_PURPOSE_shift

#define sk_X509_PURPOSE_shift

(

sk

)

Value:

((X509_PURPOSE *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)))

sk_X509_PURPOSE_sort

#define sk_X509_PURPOSE_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))

sk_X509_PURPOSE_value

#define sk_X509_PURPOSE_value	(		sk,
			i
	)

Value:

((X509_PURPOSE *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i)))

sk_X509_PURPOSE_zero

#define sk_X509_PURPOSE_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk));

sk_X509_push

#define sk_X509_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \
          CHECKED_CAST(void *, X509 *, p))

sk_X509_REVOKED_deep_copy

#define sk_X509_REVOKED_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_REVOKED) *)sk_deep_copy(                               \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk),  \
      CHECKED_CAST(void *(*)(void *), X509_REVOKED *(*)(X509_REVOKED *), \
                   copy_func),                                           \
      CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func)))

sk_X509_REVOKED_delete

#define sk_X509_REVOKED_delete	(		sk,
			where
	)

Value:

((X509_REVOKED *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where)))

sk_X509_REVOKED_delete_ptr

#define sk_X509_REVOKED_delete_ptr	(		sk,
			p
	)

Value:

((X509_REVOKED *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
      CHECKED_CAST(void *, X509_REVOKED *, p)))

sk_X509_REVOKED_dup

#define sk_X509_REVOKED_dup

(

sk

)

Value:

((STACK_OF(X509_REVOKED) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk)))

sk_X509_REVOKED_find

#define sk_X509_REVOKED_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_REVOKED *, p))

sk_X509_REVOKED_free

#define sk_X509_REVOKED_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

sk_X509_REVOKED_insert

#define sk_X509_REVOKED_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
            CHECKED_CAST(void *, X509_REVOKED *, p), (where))

sk_X509_REVOKED_is_sorted

#define sk_X509_REVOKED_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))

sk_X509_REVOKED_new

#define sk_X509_REVOKED_new

(

comp

)

Value:

((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST(                              \
      stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \
      comp)))

sk_X509_REVOKED_new_null

#define sk_X509_REVOKED_new_null

(

)

((STACK_OF(X509_REVOKED) *)sk_new_null())

sk_X509_REVOKED_num

#define sk_X509_REVOKED_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))

sk_X509_REVOKED_pop

#define sk_X509_REVOKED_pop

(

sk

)

((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

sk_X509_REVOKED_pop_free

#define sk_X509_REVOKED_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                              \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))

sk_X509_REVOKED_push

#define sk_X509_REVOKED_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \
          CHECKED_CAST(void *, X509_REVOKED *, p))

sk_X509_REVOKED_set

#define sk_X509_REVOKED_set	(		sk,
			i,
			p
	)

Value:

((X509_REVOKED *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \
      CHECKED_CAST(void *, X509_REVOKED *, p)))

sk_X509_REVOKED_set_cmp_func

#define sk_X509_REVOKED_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk),                  \
      CHECKED_CAST(stack_cmp_func,                                           \
                   int (*)(const X509_REVOKED **a, const X509_REVOKED **b),  \
                   comp)))

sk_X509_REVOKED_shift

#define sk_X509_REVOKED_shift

(

sk

)

Value:

((X509_REVOKED *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)))

sk_X509_REVOKED_sort

#define sk_X509_REVOKED_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))

sk_X509_REVOKED_value

#define sk_X509_REVOKED_value	(		sk,
			i
	)

Value:

((X509_REVOKED *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk), (i)))

sk_X509_REVOKED_zero

#define sk_X509_REVOKED_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk));

sk_X509_set

#define sk_X509_set	(		sk,
			i,
			p
	)

Value:

((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \
                  CHECKED_CAST(void *, X509 *, p)))

sk_X509_set_cmp_func

#define sk_X509_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func(                \
      CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk),                         \
      CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \
                   comp)))

sk_X509_shift

#define sk_X509_shift

(

sk

)

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

sk_X509_sort

#define sk_X509_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))

sk_X509_TRUST_deep_copy

#define sk_X509_TRUST_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_TRUST) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), \
      CHECKED_CAST(void *(*)(void *), X509_TRUST *(*)(X509_TRUST *),  \
                   copy_func),                                        \
      CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func)))

sk_X509_TRUST_delete

#define sk_X509_TRUST_delete	(		sk,
			where
	)

Value:

((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
                           (where)))

sk_X509_TRUST_delete_ptr

#define sk_X509_TRUST_delete_ptr	(		sk,
			p
	)

Value:

((X509_TRUST *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
      CHECKED_CAST(void *, X509_TRUST *, p)))

sk_X509_TRUST_dup

#define sk_X509_TRUST_dup

(

sk

)

Value:

((STACK_OF(X509_TRUST) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk)))

sk_X509_TRUST_find

#define sk_X509_TRUST_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \
          CHECKED_CAST(void *, X509_TRUST *, p))

sk_X509_TRUST_free

#define sk_X509_TRUST_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

sk_X509_TRUST_insert

#define sk_X509_TRUST_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
            CHECKED_CAST(void *, X509_TRUST *, p), (where))

sk_X509_TRUST_is_sorted

#define sk_X509_TRUST_is_sorted

(

sk

)

sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))

sk_X509_TRUST_new

#define sk_X509_TRUST_new

(

comp

)

Value:

((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST(                            \
      stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \
      comp)))

sk_X509_TRUST_new_null

#define sk_X509_TRUST_new_null

(

)

((STACK_OF(X509_TRUST) *)sk_new_null())

sk_X509_TRUST_num

#define sk_X509_TRUST_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))

sk_X509_TRUST_pop

#define sk_X509_TRUST_pop

(

sk

)

((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

sk_X509_TRUST_pop_free

#define sk_X509_TRUST_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(                                            \
      CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
      CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))

sk_X509_TRUST_push

#define sk_X509_TRUST_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
          CHECKED_CAST(void *, X509_TRUST *, p))

sk_X509_TRUST_set

#define sk_X509_TRUST_set	(		sk,
			i,
			p
	)

Value:

((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \
                        (i), CHECKED_CAST(void *, X509_TRUST *, p)))

sk_X509_TRUST_set_cmp_func

#define sk_X509_TRUST_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \
      CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk),                \
      CHECKED_CAST(stack_cmp_func,                                       \
                   int (*)(const X509_TRUST **a, const X509_TRUST **b),  \
                   comp)))

sk_X509_TRUST_shift

#define sk_X509_TRUST_shift

(

sk

)

((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)))

sk_X509_TRUST_sort

#define sk_X509_TRUST_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))

sk_X509_TRUST_value

#define sk_X509_TRUST_value	(		sk,
			i
	)

Value:

((X509_TRUST *)sk_value(         \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), (i)))

sk_X509_TRUST_zero

#define sk_X509_TRUST_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk));

sk_X509_value

#define sk_X509_value	(		sk,
			i
	)

Value:

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

sk_X509_VERIFY_PARAM_deep_copy

#define sk_X509_VERIFY_PARAM_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509_VERIFY_PARAM) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                        \
                   X509_VERIFY_PARAM *(*)(X509_VERIFY_PARAM *), copy_func),  \
      CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *),          \
                   free_func)))

sk_X509_VERIFY_PARAM_delete

#define sk_X509_VERIFY_PARAM_delete	(		sk,
			where
	)

Value:

((X509_VERIFY_PARAM *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where)))

sk_X509_VERIFY_PARAM_delete_ptr

#define sk_X509_VERIFY_PARAM_delete_ptr	(		sk,
			p
	)

Value:

((X509_VERIFY_PARAM *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
      CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

sk_X509_VERIFY_PARAM_dup

#define sk_X509_VERIFY_PARAM_dup

(

sk

)

Value:

((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)))

sk_X509_VERIFY_PARAM_find

#define sk_X509_VERIFY_PARAM_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
          (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

sk_X509_VERIFY_PARAM_free

#define sk_X509_VERIFY_PARAM_free

(

sk

)

sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

sk_X509_VERIFY_PARAM_insert

#define sk_X509_VERIFY_PARAM_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
            CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where))

sk_X509_VERIFY_PARAM_is_sorted

#define sk_X509_VERIFY_PARAM_is_sorted

(

sk

)

Value:

sk_is_sorted(                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

sk_X509_VERIFY_PARAM_new

#define sk_X509_VERIFY_PARAM_new

(

comp

)

Value:

((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST(                   \
      stack_cmp_func,                                                    \
      int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \
      comp)))

sk_X509_VERIFY_PARAM_new_null

#define sk_X509_VERIFY_PARAM_new_null

(

)

((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null())

sk_X509_VERIFY_PARAM_num

#define sk_X509_VERIFY_PARAM_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))

sk_X509_VERIFY_PARAM_pop

#define sk_X509_VERIFY_PARAM_pop

(

sk

)

Value:

((X509_VERIFY_PARAM *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

sk_X509_VERIFY_PARAM_pop_free

#define sk_X509_VERIFY_PARAM_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \
                           free_func))

sk_X509_VERIFY_PARAM_push

#define sk_X509_VERIFY_PARAM_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \
          CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))

sk_X509_VERIFY_PARAM_set

#define sk_X509_VERIFY_PARAM_set	(		sk,
			i,
			p
	)

Value:

((X509_VERIFY_PARAM *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \
      CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)))

sk_X509_VERIFY_PARAM_set_cmp_func

#define sk_X509_VERIFY_PARAM_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b))        \
       sk_set_cmp_func(                                                       \
           CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a,  \
                                                const X509_VERIFY_PARAM **b), \
                        comp)))

sk_X509_VERIFY_PARAM_shift

#define sk_X509_VERIFY_PARAM_shift

(

sk

)

Value:

((X509_VERIFY_PARAM *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)))

sk_X509_VERIFY_PARAM_sort

#define sk_X509_VERIFY_PARAM_sort

(

sk

)

sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))

sk_X509_VERIFY_PARAM_value

#define sk_X509_VERIFY_PARAM_value	(		sk,
			i
	)

Value:

((X509_VERIFY_PARAM *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \
      (i)))

sk_X509_VERIFY_PARAM_zero

#define sk_X509_VERIFY_PARAM_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk));

sk_X509_zero

#define sk_X509_zero

(

sk

)

sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk));

sk_X509V3_EXT_METHOD_deep_copy

#define sk_X509V3_EXT_METHOD_deep_copy	(		sk,
			copy_func,
			free_func
	)

Value:

((STACK_OF(X509V3_EXT_METHOD) *)sk_deep_copy(                              \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \
      CHECKED_CAST(void *(*)(void *),                                        \
                   X509V3_EXT_METHOD *(*)(X509V3_EXT_METHOD *), copy_func),  \
      CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *),          \
                   free_func)))

sk_X509V3_EXT_METHOD_delete

#define sk_X509V3_EXT_METHOD_delete	(		sk,
			where
	)

Value:

((X509V3_EXT_METHOD *)sk_delete(             \
      CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where)))

sk_X509V3_EXT_METHOD_delete_ptr

#define sk_X509V3_EXT_METHOD_delete_ptr	(		sk,
			p
	)

Value:

((X509V3_EXT_METHOD *)sk_delete_ptr(                           \
      CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
      CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

sk_X509V3_EXT_METHOD_dup

#define sk_X509V3_EXT_METHOD_dup

(

sk

)

Value:

((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)))

sk_X509V3_EXT_METHOD_find

#define sk_X509V3_EXT_METHOD_find	(		sk,
			out_index,
			p
	)

Value:

sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
          (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

sk_X509V3_EXT_METHOD_free

#define sk_X509V3_EXT_METHOD_free

(

sk

)

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

sk_X509V3_EXT_METHOD_insert

#define sk_X509V3_EXT_METHOD_insert	(		sk,
			p,
			where
	)

Value:

sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
            CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where))

sk_X509V3_EXT_METHOD_is_sorted

#define sk_X509V3_EXT_METHOD_is_sorted

(

sk

)

Value:

sk_is_sorted(                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

sk_X509V3_EXT_METHOD_new

#define sk_X509V3_EXT_METHOD_new

(

comp

)

Value:

((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST(                   \
      stack_cmp_func,                                                    \
      int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \
      comp)))

sk_X509V3_EXT_METHOD_new_null

#define sk_X509V3_EXT_METHOD_new_null

(

)

((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null())

sk_X509V3_EXT_METHOD_num

#define sk_X509V3_EXT_METHOD_num

(

sk

)

sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))

sk_X509V3_EXT_METHOD_pop

#define sk_X509V3_EXT_METHOD_pop

(

sk

)

Value:

((X509V3_EXT_METHOD *)sk_pop(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

sk_X509V3_EXT_METHOD_pop_free

#define sk_X509V3_EXT_METHOD_pop_free	(		sk,
			free_func
	)

Value:

sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),    \
              CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \
                           free_func))

sk_X509V3_EXT_METHOD_push

#define sk_X509V3_EXT_METHOD_push	(		sk,
			p
	)

Value:

sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \
          CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))

sk_X509V3_EXT_METHOD_set

#define sk_X509V3_EXT_METHOD_set	(		sk,
			i,
			p
	)

Value:

((X509V3_EXT_METHOD *)sk_set(                                       \
      CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \
      CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)))

sk_X509V3_EXT_METHOD_set_cmp_func

#define sk_X509V3_EXT_METHOD_set_cmp_func	(		sk,
			comp
	)

Value:

((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b))        \
       sk_set_cmp_func(                                                       \
           CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk),         \
           CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a,  \
                                                const X509V3_EXT_METHOD **b), \
                        comp)))

sk_X509V3_EXT_METHOD_shift

#define sk_X509V3_EXT_METHOD_shift

(

sk

)

Value:

((X509V3_EXT_METHOD *)sk_shift(      \
      CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)))

sk_X509V3_EXT_METHOD_sort

#define sk_X509V3_EXT_METHOD_sort

(

sk

)

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

sk_X509V3_EXT_METHOD_value

#define sk_X509V3_EXT_METHOD_value	(		sk,
			i
	)

Value:

((X509V3_EXT_METHOD *)sk_value(                                            \
      CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \
      (i)))

sk_X509V3_EXT_METHOD_zero

#define sk_X509V3_EXT_METHOD_zero

(

sk

)

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