Mercurial > hg > CbC > CbC_gcc
comparison gcc/tristate.cc @ 145:1830386684a0
gcc-9.2.0
author | anatofuz |
---|---|
date | Thu, 13 Feb 2020 11:34:05 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
131:84e7813d76e9 | 145:1830386684a0 |
---|---|
1 /* "True" vs "False" vs "Unknown". | |
2 Copyright (C) 2019-2020 Free Software Foundation, Inc. | |
3 Contributed by David Malcolm <dmalcolm@redhat.com>. | |
4 | |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by | |
9 the Free Software Foundation; either version 3, or (at your option) | |
10 any later version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, but | |
13 WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with GCC; see the file COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 #include "config.h" | |
22 #include "system.h" | |
23 #include "coretypes.h" | |
24 #include "tristate.h" | |
25 #include "selftest.h" | |
26 | |
27 const char * | |
28 tristate::as_string () const | |
29 { | |
30 switch (m_value) | |
31 { | |
32 default: | |
33 gcc_unreachable (); | |
34 case TS_UNKNOWN: | |
35 return "UNKNOWN"; | |
36 case TS_TRUE: | |
37 return "TRUE"; | |
38 case TS_FALSE: | |
39 return "FALSE"; | |
40 } | |
41 } | |
42 | |
43 tristate | |
44 tristate::not_ () const | |
45 { | |
46 switch (m_value) | |
47 { | |
48 default: | |
49 gcc_unreachable (); | |
50 case TS_UNKNOWN: | |
51 return tristate (TS_UNKNOWN); | |
52 case TS_TRUE: | |
53 return tristate (TS_FALSE); | |
54 case TS_FALSE: | |
55 return tristate (TS_TRUE); | |
56 } | |
57 } | |
58 | |
59 tristate | |
60 tristate::or_ (tristate other) const | |
61 { | |
62 switch (m_value) | |
63 { | |
64 default: | |
65 gcc_unreachable (); | |
66 case TS_UNKNOWN: | |
67 if (other.is_true ()) | |
68 return tristate (TS_TRUE); | |
69 else | |
70 return tristate (TS_UNKNOWN); | |
71 case TS_FALSE: | |
72 return other; | |
73 case TS_TRUE: | |
74 return tristate (TS_TRUE); | |
75 } | |
76 } | |
77 | |
78 tristate | |
79 tristate::and_ (tristate other) const | |
80 { | |
81 switch (m_value) | |
82 { | |
83 default: | |
84 gcc_unreachable (); | |
85 case TS_UNKNOWN: | |
86 if (other.is_false ()) | |
87 return tristate (TS_FALSE); | |
88 else | |
89 return tristate (TS_UNKNOWN); | |
90 case TS_TRUE: | |
91 return other; | |
92 case TS_FALSE: | |
93 return tristate (TS_FALSE); | |
94 } | |
95 } | |
96 | |
97 #if CHECKING_P | |
98 | |
99 namespace selftest { | |
100 | |
101 #define ASSERT_TRISTATE_TRUE(TRISTATE) \ | |
102 SELFTEST_BEGIN_STMT \ | |
103 ASSERT_EQ (TRISTATE, tristate (tristate::TS_TRUE)); \ | |
104 SELFTEST_END_STMT | |
105 | |
106 #define ASSERT_TRISTATE_FALSE(TRISTATE) \ | |
107 SELFTEST_BEGIN_STMT \ | |
108 ASSERT_EQ (TRISTATE, tristate (tristate::TS_FALSE)); \ | |
109 SELFTEST_END_STMT | |
110 | |
111 #define ASSERT_TRISTATE_UNKNOWN(TRISTATE) \ | |
112 SELFTEST_BEGIN_STMT \ | |
113 ASSERT_EQ (TRISTATE, tristate (tristate::TS_UNKNOWN)); \ | |
114 SELFTEST_END_STMT | |
115 | |
116 /* Test tristate's ctors, along with is_*, as_string, operator==, and | |
117 operator!=. */ | |
118 | |
119 static void | |
120 test_ctors () | |
121 { | |
122 tristate u (tristate::TS_UNKNOWN); | |
123 ASSERT_FALSE (u.is_known ()); | |
124 ASSERT_FALSE (u.is_true ()); | |
125 ASSERT_FALSE (u.is_false ()); | |
126 ASSERT_STREQ (u.as_string (), "UNKNOWN"); | |
127 | |
128 tristate t (tristate::TS_TRUE); | |
129 ASSERT_TRUE (t.is_known ()); | |
130 ASSERT_TRUE (t.is_true ()); | |
131 ASSERT_FALSE (t.is_false ()); | |
132 ASSERT_STREQ (t.as_string (), "TRUE"); | |
133 | |
134 tristate f (tristate::TS_FALSE); | |
135 ASSERT_TRUE (f.is_known ()); | |
136 ASSERT_FALSE (f.is_true ()); | |
137 ASSERT_TRUE (f.is_false ()); | |
138 ASSERT_STREQ (f.as_string (), "FALSE"); | |
139 | |
140 ASSERT_EQ (u, u); | |
141 ASSERT_EQ (t, t); | |
142 ASSERT_EQ (f, f); | |
143 ASSERT_NE (u, t); | |
144 ASSERT_NE (u, f); | |
145 ASSERT_NE (t, f); | |
146 | |
147 tristate t2 (true); | |
148 ASSERT_TRUE (t2.is_true ()); | |
149 ASSERT_EQ (t, t2); | |
150 | |
151 tristate f2 (false); | |
152 ASSERT_TRUE (f2.is_false ()); | |
153 ASSERT_EQ (f, f2); | |
154 | |
155 tristate u2 (tristate::unknown ()); | |
156 ASSERT_TRUE (!u2.is_known ()); | |
157 ASSERT_EQ (u, u2); | |
158 } | |
159 | |
160 /* Test && on tristate instances. */ | |
161 | |
162 static void | |
163 test_and () | |
164 { | |
165 ASSERT_TRISTATE_UNKNOWN (tristate::unknown () && tristate::unknown ()); | |
166 | |
167 ASSERT_TRISTATE_FALSE (tristate (false) && tristate (false)); | |
168 ASSERT_TRISTATE_FALSE (tristate (false) && tristate (true)); | |
169 ASSERT_TRISTATE_FALSE (tristate (true) && tristate (false)); | |
170 ASSERT_TRISTATE_TRUE (tristate (true) && tristate (true)); | |
171 | |
172 ASSERT_TRISTATE_UNKNOWN (tristate::unknown () && tristate (true)); | |
173 ASSERT_TRISTATE_UNKNOWN (tristate (true) && tristate::unknown ()); | |
174 | |
175 ASSERT_TRISTATE_FALSE (tristate::unknown () && tristate (false)); | |
176 ASSERT_TRISTATE_FALSE (tristate (false) && tristate::unknown ()); | |
177 } | |
178 | |
179 /* Test || on tristate instances. */ | |
180 | |
181 static void | |
182 test_or () | |
183 { | |
184 ASSERT_TRISTATE_UNKNOWN (tristate::unknown () || tristate::unknown ()); | |
185 | |
186 ASSERT_TRISTATE_FALSE (tristate (false) || tristate (false)); | |
187 ASSERT_TRISTATE_TRUE (tristate (false) || tristate (true)); | |
188 ASSERT_TRISTATE_TRUE (tristate (true) || tristate (false)); | |
189 ASSERT_TRISTATE_TRUE (tristate (true) || tristate (true)); | |
190 | |
191 ASSERT_TRISTATE_TRUE (tristate::unknown () || tristate (true)); | |
192 ASSERT_TRISTATE_TRUE (tristate (true) || tristate::unknown ()); | |
193 | |
194 ASSERT_TRISTATE_UNKNOWN (tristate::unknown () || tristate (false)); | |
195 ASSERT_TRISTATE_UNKNOWN (tristate (false) || tristate::unknown ()); | |
196 } | |
197 | |
198 /* Test ! on tristate instances. */ | |
199 | |
200 static void | |
201 test_not () | |
202 { | |
203 ASSERT_TRISTATE_UNKNOWN (!tristate::unknown ()); | |
204 ASSERT_TRISTATE_FALSE (!tristate (true)); | |
205 ASSERT_TRISTATE_TRUE (!tristate (false)); | |
206 } | |
207 | |
208 /* Run all of the selftests within this file. */ | |
209 | |
210 void | |
211 tristate_cc_tests () | |
212 { | |
213 test_ctors (); | |
214 test_and (); | |
215 test_or (); | |
216 test_not (); | |
217 } | |
218 | |
219 } // namespace selftest | |
220 | |
221 #endif /* CHECKING_P */ |