Implementation details. More...

Data Structures
struct	T_case_context

struct	T_check_context

struct	T_check_context_msg

Macros
#define	T_CHECK_STOP 1U

#define	T_CHECK_QUIET 2U

#define	T_CHECK_STEP_FLAG 4U

#define	T_CHECK_STEP_TO_FLAGS(step) ((unsigned int)(step) << 8)

#define	T_CHECK_STEP_FROM_FLAGS(flags) ((flags) >> 8)

#define	T_CHECK_STEP(step) (T_CHECK_STEP_TO_FLAGS(step) \| T_CHECK_STEP_FLAG)

#define	T_flags_true(a, flags, ...)

#define	T_flags_eq(a, e, flags, ...) T_flags_true((a) == (e), flags, __VA_ARGS__)

#define	T_flags_ne(a, e, flags, ...) T_flags_true((a) != (e), flags, __VA_ARGS__)

#define	T_flags_eq_ptr(a, e, flags, sa, se)

#define	T_flags_ne_ptr(a, e, flags, sa, se)

#define	T_flags_null(a, flags, sa)

#define	T_flags_not_null(a, flags, sa)

#define	T_flags_eq_mem(a, e, n, flags, sa, se, sn)

#define	T_flags_ne_mem(a, e, n, flags, sa, se, sn)

#define	T_flags_eq_str(a, e, flags)

#define	T_flags_ne_str(a, e, flags)

#define	T_flags_eq_nstr(a, e, n, flags)

#define	T_flags_ne_nstr(a, e, n, flags)

#define	T_flags_eq_char(a, e, flags)

#define	T_flags_ne_char(a, e, flags)

#define	T_flags_eq_int(a, e, flags)

#define	T_flags_ne_int(a, e, flags)

#define	T_flags_ge_int(a, e, flags)

#define	T_flags_gt_int(a, e, flags)

#define	T_flags_le_int(a, e, flags)

#define	T_flags_lt_int(a, e, flags)

#define	T_flags_eq_uint(a, e, flags)

#define	T_flags_ne_uint(a, e, flags)

#define	T_flags_ge_uint(a, e, flags)

#define	T_flags_gt_uint(a, e, flags)

#define	T_flags_le_uint(a, e, flags)

#define	T_flags_lt_uint(a, e, flags)

#define	T_flags_eq_long(a, e, flags)

#define	T_flags_ne_long(a, e, flags)

#define	T_flags_ge_long(a, e, flags)

#define	T_flags_gt_long(a, e, flags)

#define	T_flags_le_long(a, e, flags)

#define	T_flags_lt_long(a, e, flags)

#define	T_flags_eq_ulong(a, e, flags)

#define	T_flags_ne_ulong(a, e, flags)

#define	T_flags_ge_ulong(a, e, flags)

#define	T_flags_gt_ulong(a, e, flags)

#define	T_flags_le_ulong(a, e, flags)

#define	T_flags_lt_ulong(a, e, flags)

#define	T_flags_eq_ll(a, e, flags)

#define	T_flags_ne_ll(a, e, flags)

#define	T_flags_ge_ll(a, e, flags)

#define	T_flags_gt_ll(a, e, flags)

#define	T_flags_le_ll(a, e, flags)

#define	T_flags_lt_ll(a, e, flags)

#define	T_flags_eq_ull(a, e, flags)

#define	T_flags_ne_ull(a, e, flags)

#define	T_flags_ge_ull(a, e, flags)

#define	T_flags_gt_ull(a, e, flags)

#define	T_flags_le_ull(a, e, flags)

#define	T_flags_lt_ull(a, e, flags)

#define	T_flags_eno(a, e, flags)

#define	T_flags_eno_success(a, flags)

#define	T_flags_psx_error(a, eno, flags)

#define	T_flags_psx_success(a, flags)

Typedefs
typedef struct T_case_context	T_case_context

Functions
void	T_case_register (T_case_context *)

void	T_check_true (bool, const T_check_context , const char ,...)

void	T_check_eq_ptr (const void , const T_check_context_msg , const void *)

void	T_check_ne_ptr (const void , const T_check_context_msg , const void *)

void	T_check_null (const void , const T_check_context_msg )

void	T_check_not_null (const void , const T_check_context_msg )

void	T_check_eq_mem (const void , const T_check_context_msg , const void *, size_t)

void	T_check_ne_mem (const void , const T_check_context_msg , const void *, size_t)

void	T_check_eq_str (const char , const T_check_context , const char *)

void	T_check_ne_str (const char , const T_check_context , const char *)

void	T_check_eq_nstr (const char , const T_check_context , const char *, size_t)

void	T_check_ne_nstr (const char , const T_check_context , const char *, size_t)

void	T_check_eq_char (char, const T_check_context *, char)

void	T_check_ne_char (char, const T_check_context *, char)

void	T_check_eq_int (int, const T_check_context *, int)

void	T_check_ne_int (int, const T_check_context *, int)

void	T_check_ge_int (int, const T_check_context *, int)

void	T_check_gt_int (int, const T_check_context *, int)

void	T_check_le_int (int, const T_check_context *, int)

void	T_check_lt_int (int, const T_check_context *, int)

void	T_check_eq_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_ne_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_ge_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_gt_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_le_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_lt_uint (unsigned int, const T_check_context *, unsigned int)

void	T_check_eq_long (long, const T_check_context *, long)

void	T_check_ne_long (long, const T_check_context *, long)

void	T_check_ge_long (long, const T_check_context *, long)

void	T_check_gt_long (long, const T_check_context *, long)

void	T_check_le_long (long, const T_check_context *, long)

void	T_check_lt_long (long, const T_check_context *, long)

void	T_check_eq_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_ne_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_ge_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_gt_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_le_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_lt_ulong (unsigned long, const T_check_context *, unsigned long)

void	T_check_eq_ll (long long, const T_check_context *, long long)

void	T_check_ne_ll (long long, const T_check_context *, long long)

void	T_check_ge_ll (long long, const T_check_context *, long long)

void	T_check_gt_ll (long long, const T_check_context *, long long)

void	T_check_le_ll (long long, const T_check_context *, long long)

void	T_check_lt_ll (long long, const T_check_context *, long long)

void	T_check_eq_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_ne_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_ge_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_gt_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_le_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_lt_ull (unsigned long long, const T_check_context *, unsigned long long)

void	T_check_eno (int, const T_check_context *, int)

void	T_check_eno_success (int, const T_check_context *)

void	T_check_psx_error (int, const T_check_context *, int)

void	T_check_psx_success (int, const T_check_context *)

Detailed Description

Implementation details.

Macro Definition Documentation

◆ T_flags_eno

#define T_flags_eno	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eno(a, &T_check_instance, e);               \
}

◆ T_flags_eno_success

#define T_flags_eno_success	(	a,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eno_success(a, &T_check_instance);          \
}

◆ T_flags_eq_char

#define T_flags_eq_char	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_char(a, &T_check_instance, e);           \
}

◆ T_flags_eq_int

#define T_flags_eq_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_int(a, &T_check_instance, e);            \
}

◆ T_flags_eq_ll

#define T_flags_eq_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_ll(a, &T_check_instance, e);             \
}

◆ T_flags_eq_long

#define T_flags_eq_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_long(a, &T_check_instance, e);           \
}

◆ T_flags_eq_mem

#define T_flags_eq_mem	(	a,
		e,
		n,
		flags,
		sa,
		se,
		sn
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags },               \
        "memcmp(" sa ", " se ", " sn ") == 0" };            \
    T_check_eq_mem(a, &T_check_instance, e, n);         \
}

◆ T_flags_eq_nstr

#define T_flags_eq_nstr	(	a,
		e,
		n,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_nstr(a, &T_check_instance, e, n);            \
}

◆ T_flags_eq_ptr

#define T_flags_eq_ptr	(	a,
		e,
		flags,
		sa,
		se
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags }, sa " == " se };       \
    T_check_eq_ptr(a, &T_check_instance, e);            \
}

◆ T_flags_eq_str

#define T_flags_eq_str	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_str(a, &T_check_instance, e);            \
}

◆ T_flags_eq_uint

#define T_flags_eq_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_uint(a, &T_check_instance, e);           \
}

◆ T_flags_eq_ull

#define T_flags_eq_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_ull(a, &T_check_instance, e);            \
}

◆ T_flags_eq_ulong

#define T_flags_eq_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_eq_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_ge_int

#define T_flags_ge_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_int(a, &T_check_instance, e);            \
}

◆ T_flags_ge_ll

#define T_flags_ge_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_ll(a, &T_check_instance, e);             \
}

◆ T_flags_ge_long

#define T_flags_ge_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_long(a, &T_check_instance, e);           \
}

◆ T_flags_ge_uint

#define T_flags_ge_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_uint(a, &T_check_instance, e);           \
}

◆ T_flags_ge_ull

#define T_flags_ge_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_ull(a, &T_check_instance, e);            \
}

◆ T_flags_ge_ulong

#define T_flags_ge_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ge_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_gt_int

#define T_flags_gt_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_int(a, &T_check_instance, e);            \
}

◆ T_flags_gt_ll

#define T_flags_gt_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_ll(a, &T_check_instance, e);             \
}

◆ T_flags_gt_long

#define T_flags_gt_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_long(a, &T_check_instance, e);           \
}

◆ T_flags_gt_uint

#define T_flags_gt_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_uint(a, &T_check_instance, e);           \
}

◆ T_flags_gt_ull

#define T_flags_gt_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_ull(a, &T_check_instance, e);            \
}

◆ T_flags_gt_ulong

#define T_flags_gt_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_gt_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_le_int

#define T_flags_le_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_int(a, &T_check_instance, e);            \
}

◆ T_flags_le_ll

#define T_flags_le_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_ll(a, &T_check_instance, e);             \
}

◆ T_flags_le_long

#define T_flags_le_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_long(a, &T_check_instance, e);           \
}

◆ T_flags_le_uint

#define T_flags_le_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_uint(a, &T_check_instance, e);           \
}

◆ T_flags_le_ull

#define T_flags_le_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_ull(a, &T_check_instance, e);            \
}

◆ T_flags_le_ulong

#define T_flags_le_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_le_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_lt_int

#define T_flags_lt_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_int(a, &T_check_instance, e);            \
}

◆ T_flags_lt_ll

#define T_flags_lt_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_ll(a, &T_check_instance, e);             \
}

◆ T_flags_lt_long

#define T_flags_lt_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_long(a, &T_check_instance, e);           \
}

◆ T_flags_lt_uint

#define T_flags_lt_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_uint(a, &T_check_instance, e);           \
}

◆ T_flags_lt_ull

#define T_flags_lt_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_ull(a, &T_check_instance, e);            \
}

◆ T_flags_lt_ulong

#define T_flags_lt_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_lt_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_ne_char

#define T_flags_ne_char	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_char(a, &T_check_instance, e);           \
}

◆ T_flags_ne_int

#define T_flags_ne_int	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_int(a, &T_check_instance, e);            \
}

◆ T_flags_ne_ll

#define T_flags_ne_ll	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_ll(a, &T_check_instance, e);             \
}

◆ T_flags_ne_long

#define T_flags_ne_long	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_long(a, &T_check_instance, e);           \
}

◆ T_flags_ne_mem

#define T_flags_ne_mem	(	a,
		e,
		n,
		flags,
		sa,
		se,
		sn
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags },               \
        "memcmp(" sa ", " se ", " sn ") != 0" };            \
    T_check_ne_mem(a, &T_check_instance, e, n);         \
}

◆ T_flags_ne_nstr

#define T_flags_ne_nstr	(	a,
		e,
		n,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_nstr(a, &T_check_instance, e, n);            \
}

◆ T_flags_ne_ptr

#define T_flags_ne_ptr	(	a,
		e,
		flags,
		sa,
		se
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags }, sa " != " se };       \
    T_check_ne_ptr(a, &T_check_instance, e);            \
}

◆ T_flags_ne_str

#define T_flags_ne_str	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_str(a, &T_check_instance, e);            \
}

◆ T_flags_ne_uint

#define T_flags_ne_uint	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_uint(a, &T_check_instance, e);           \
}

◆ T_flags_ne_ull

#define T_flags_ne_ull	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_ull(a, &T_check_instance, e);            \
}

◆ T_flags_ne_ulong

#define T_flags_ne_ulong	(	a,
		e,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_ne_ulong(a, &T_check_instance, e);          \
}

◆ T_flags_not_null

#define T_flags_not_null	(	a,
		flags,
		sa
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags }, sa };         \
    T_check_not_null(a, &T_check_instance);             \
}

◆ T_flags_null

#define T_flags_null	(	a,
		flags,
		sa
	)

Value:

{                                   \
    static const T_check_context_msg T_check_instance = {       \
        { T_FILE_NAME, __LINE__, flags }, sa };         \
    T_check_null(a, &T_check_instance);             \
}

◆ T_flags_psx_error

#define T_flags_psx_error	(	a,
		eno,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_psx_error(a, &T_check_instance, eno);           \
}

◆ T_flags_psx_success

#define T_flags_psx_success	(	a,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_psx_success(a, &T_check_instance);          \
}

◆ T_flags_true

#define T_flags_true	(	a,
		flags,
		...
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, flags };             \
    T_check_true(a, &T_check_instance, __VA_ARGS__);        \
}

Data Structures

Macros

Typedefs

Functions

Detailed Description

Macro Definition Documentation

◆ T_flags_eno

◆ T_flags_eno_success

◆ T_flags_eq_char

◆ T_flags_eq_int

◆ T_flags_eq_ll

◆ T_flags_eq_long

◆ T_flags_eq_mem

◆ T_flags_eq_nstr

◆ T_flags_eq_ptr

◆ T_flags_eq_str

◆ T_flags_eq_uint

◆ T_flags_eq_ull

◆ T_flags_eq_ulong

◆ T_flags_ge_int

◆ T_flags_ge_ll

◆ T_flags_ge_long

◆ T_flags_ge_uint

◆ T_flags_ge_ull

◆ T_flags_ge_ulong

◆ T_flags_gt_int

◆ T_flags_gt_ll

◆ T_flags_gt_long

◆ T_flags_gt_uint

◆ T_flags_gt_ull

◆ T_flags_gt_ulong

◆ T_flags_le_int

◆ T_flags_le_ll

◆ T_flags_le_long

◆ T_flags_le_uint

◆ T_flags_le_ull

◆ T_flags_le_ulong

◆ T_flags_lt_int

◆ T_flags_lt_ll

◆ T_flags_lt_long

◆ T_flags_lt_uint

◆ T_flags_lt_ull

◆ T_flags_lt_ulong

◆ T_flags_ne_char

◆ T_flags_ne_int

◆ T_flags_ne_ll

◆ T_flags_ne_long

◆ T_flags_ne_mem

◆ T_flags_ne_nstr

◆ T_flags_ne_ptr

◆ T_flags_ne_str

◆ T_flags_ne_uint

◆ T_flags_ne_ull

◆ T_flags_ne_ulong

◆ T_flags_not_null

◆ T_flags_null

◆ T_flags_psx_error

◆ T_flags_psx_success

◆ T_flags_true