init

hc

2024-03-22 a0752693d998599af469473b8dc239ef973a012f

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#define LargestIntegralType unsigned long long
 
 
void _assert_true(const LargestIntegralType result,
                  const char* const expression,
                  const char * const file, const int line)
{
    if (!result) {
        __coverity_panic__();
    }
}
 
void _assert_int_equal(
    const LargestIntegralType a, const LargestIntegralType b,
    const char * const file, const int line)
{
    if (a != b) {
        __coverity_panic__();
    }
}
 
void _assert_int_not_equal(
    const LargestIntegralType a, const LargestIntegralType b,
    const char * const file, const int line)
{
    if (a == b) {
        __coverity_panic__();
    }
}
 
void _assert_return_code(const LargestIntegralType result,
                         size_t rlen,
                         const LargestIntegralType error,
                         const char * const expression,
                         const char * const file,
                         const int line)
{
    if (result != 0) {
        __coverity_panic__();
    }
}
 
void _assert_string_equal(const char * const a, const char * const b,
                          const char * const file, const int line)
{
    char ch;
    int cmp;
 
    __coverity_weak_guard_sink__(a, b);
    __coverity_weak_guard_sink__(b, a);
 
    ch = *((char *)a);
    ch = *((char *)b);
 
    if (cmp != 0) {
        __coverity_panic__();
    }
}
 
void _assert_string_not_equal(const char * const a, const char * const b,
                              const char *file, const int line)
{
    char ch;
    int cmp;
 
    __coverity_weak_guard_sink__(a, b);
    __coverity_weak_guard_sink__(b, a);
 
    ch = *((char *)a);
    ch = *((char *)b);
 
    if (cmp == 0) {
        __coverity_panic__();
    }
}
 
void _assert_memory_equal(const void * const a, const void * const b,
                          const size_t size, const char* const file,
                          const int line)
{
    unsigned char ch;
    int cmp;
 
    __coverity_weak_guard_sink__(a, b);
    __coverity_weak_guard_sink__(b, a);
 
    ch = *((unsigned char *)a);
    ch = *((unsigned char *)b);
 
    if (cmp != 0) {
        __coverity_panic__();
    }
}
 
void _assert_memory_not_equal(const void * const a, const void * const b,
                              const size_t size, const char* const file,
                              const int line)
{
    unsigned char ch;
    int cmp;
 
    __coverity_weak_guard_sink__(a, b);
    __coverity_weak_guard_sink__(b, a);
 
    ch = *((unsigned char *)a);
    ch = *((unsigned char *)b);
 
    if (cmp == 0) {
        __coverity_panic__();
    }
}
 
void _assert_in_range(
    const LargestIntegralType value, const LargestIntegralType minimum,
    const LargestIntegralType maximum, const char* const file, const int line)
{
    if (value < minimum || value > maximum) {
        __coverity_panic__();
    }
}
 
void _assert_not_in_range(
    const LargestIntegralType value, const LargestIntegralType minimum,
    const LargestIntegralType maximum, const char* const file, const int line)
{
    if (value > minimum && value < maximum) {
        __coverity_panic__();
    }
}
 
void _assert_in_set(
    const LargestIntegralType value, const LargestIntegralType values[],
    const size_t number_of_values, const char* const file, const int line)
{
    size_t i;
 
    for (i = 0; i < number_of_values; i++) {
        if (value == values[i]) {
            return;
        }
    }
    __coverity_panic__();
}
 
void _assert_not_in_set(
    const LargestIntegralType value, const LargestIntegralType values[],
    const size_t number_of_values, const char* const file, const int line)
{
    size_t i;
 
    for (i = 0; i < number_of_values; i++) {
        if (value == values[i]) {
            __coverity_panic__();
        }
    }
}