Skip to content

Commit 45dd840

Browse files
romainbrenguierromainbrenguier
authored
Merge pull request #1728 from romainbrenguier/refactor/split-axiom-vectors
Split string generator axioms into separate vectors
2 parents fdb2ebc + 857fcf9 commit 45dd840

14 files changed

+224
-186
lines changed

‎src/solvers/refinement/string_constraint_generator.h

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,10 @@ class string_constraint_generatort final
4848

4949
/// Axioms are of three kinds: universally quantified string constraint,
5050
/// not contains string constraints and simple formulas.
51-
const std::vector<exprt> &get_axioms() const;
51+
const std::vector<exprt> &get_lemmas() const;
52+
const std::vector<string_constraintt> &get_constraints() const;
53+
const std::vector<string_not_contains_constraintt> &
54+
get_not_contains_constraints() const;
5255

5356
/// Boolean symbols for the results of some string functions
5457
const std::vector<symbol_exprt> &get_boolean_symbols() const;
@@ -349,7 +352,9 @@ class string_constraint_generatort final
349352
unsigned symbol_count=0;
350353
const messaget message;
351354

352-
std::vector<exprt> axioms;
355+
std::vector<exprt> lemmas;
356+
std::vector<string_constraintt> constraints;
357+
std::vector<string_not_contains_constraintt> not_contains_constraints;
353358
std::vector<symbol_exprt> boolean_symbols;
354359
std::vector<symbol_exprt> index_symbols;
355360
const namespacet ns;

‎src/solvers/refinement/string_constraint_generator_code_points.cpp

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -41,27 +41,27 @@ exprt string_constraint_generatort::add_axioms_for_code_point(
4141

4242
binary_relation_exprt small(code_point, ID_lt, hex010000);
4343
implies_exprt a1(small, res.axiom_for_has_length(1));
44-
axioms.push_back(a1);
44+
lemmas.push_back(a1);
4545

4646
implies_exprt a2(not_exprt(small), res.axiom_for_has_length(2));
47-
axioms.push_back(a2);
47+
lemmas.push_back(a2);
4848

4949
typecast_exprt code_point_as_char(code_point, char_type);
5050
implies_exprt a3(small, equal_exprt(res[0], code_point_as_char));
51-
axioms.push_back(a3);
51+
lemmas.push_back(a3);
5252

5353
plus_exprt first_char(
5454
hexD800, div_exprt(minus_exprt(code_point, hex010000), hex0400));
5555
implies_exprt a4(
5656
not_exprt(small),
5757
equal_exprt(res[0], typecast_exprt(first_char, char_type)));
58-
axioms.push_back(a4);
58+
lemmas.push_back(a4);
5959

6060
plus_exprt second_char(hexDC00, mod_exprt(code_point, hex0400));
6161
implies_exprt a5(
6262
not_exprt(small),
6363
equal_exprt(res[1], typecast_exprt(second_char, char_type)));
64-
axioms.push_back(a5);
64+
lemmas.push_back(a5);
6565

6666
return from_integer(0, get_return_code_type());
6767
}
@@ -136,8 +136,8 @@ exprt string_constraint_generatort::add_axioms_for_code_point_at(
136136
is_low_surrogate(str[plus_exprt_with_overflow_check(pos, index1)]);
137137
const and_exprt return_pair(is_high_surrogate(str[pos]), is_low);
138138

139-
axioms.push_back(implies_exprt(return_pair, equal_exprt(result, pair)));
140-
axioms.push_back(
139+
lemmas.push_back(implies_exprt(return_pair, equal_exprt(result, pair)));
140+
lemmas.push_back(
141141
implies_exprt(not_exprt(return_pair), equal_exprt(result, char1_as_int)));
142142
return result;
143143
}
@@ -167,8 +167,8 @@ exprt string_constraint_generatort::add_axioms_for_code_point_before(
167167
const and_exprt return_pair(
168168
is_high_surrogate(char1), is_low_surrogate(char2));
169169

170-
axioms.push_back(implies_exprt(return_pair, equal_exprt(result, pair)));
171-
axioms.push_back(
170+
lemmas.push_back(implies_exprt(return_pair, equal_exprt(result, pair)));
171+
lemmas.push_back(
172172
implies_exprt(not_exprt(return_pair), equal_exprt(result, char2_as_int)));
173173
return result;
174174
}
@@ -189,8 +189,8 @@ exprt string_constraint_generatort::add_axioms_for_code_point_count(
189189
const symbol_exprt result = fresh_symbol("code_point_count", return_type);
190190
const minus_exprt length(end, begin);
191191
const div_exprt minimum(length, from_integer(2, length.type()));
192-
axioms.push_back(binary_relation_exprt(result, ID_le, length));
193-
axioms.push_back(binary_relation_exprt(result, ID_ge, minimum));
192+
lemmas.push_back(binary_relation_exprt(result, ID_le, length));
193+
lemmas.push_back(binary_relation_exprt(result, ID_ge, minimum));
194194

195195
return result;
196196
}
@@ -212,8 +212,8 @@ exprt string_constraint_generatort::add_axioms_for_offset_by_code_point(
212212

213213
const exprt minimum = plus_exprt_with_overflow_check(index, offset);
214214
const exprt maximum = plus_exprt_with_overflow_check(minimum, offset);
215-
axioms.push_back(binary_relation_exprt(result, ID_le, maximum));
216-
axioms.push_back(binary_relation_exprt(result, ID_ge, minimum));
215+
lemmas.push_back(binary_relation_exprt(result, ID_le, maximum));
216+
lemmas.push_back(binary_relation_exprt(result, ID_ge, minimum));
217217

218218
return result;
219219
}

‎src/solvers/refinement/string_constraint_generator_comparison.cpp

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -40,11 +40,11 @@ exprt string_constraint_generatort::add_axioms_for_equals(
4040

4141

4242
implies_exprt a1(eq, equal_exprt(s1.length(), s2.length()));
43-
axioms.push_back(a1);
43+
lemmas.push_back(a1);
4444

4545
symbol_exprt qvar=fresh_univ_index("QA_equal", index_type);
4646
string_constraintt a2(qvar, s1.length(), eq, equal_exprt(s1[qvar], s2[qvar]));
47-
axioms.push_back(a2);
47+
constraints.push_back(a2);
4848

4949
symbol_exprt witness=fresh_exist_index("witness_unequal", index_type);
5050
exprt zero=from_integer(0, index_type);
@@ -56,7 +56,7 @@ exprt string_constraint_generatort::add_axioms_for_equals(
5656
notequal_exprt(s1.length(), s2.length()),
5757
equal_exprt(witness, from_integer(-1, index_type)));
5858
implies_exprt a3(not_exprt(eq), or_exprt(diff_length, witnessing));
59-
axioms.push_back(a3);
59+
lemmas.push_back(a3);
6060

6161
return tc_eq;
6262
}
@@ -124,14 +124,14 @@ exprt string_constraint_generatort::add_axioms_for_equals_ignore_case(
124124
const typet index_type = s1.length().type();
125125

126126
const implies_exprt a1(eq, equal_exprt(s1.length(), s2.length()));
127-
axioms.push_back(a1);
127+
lemmas.push_back(a1);
128128

129129
const symbol_exprt qvar =
130130
fresh_univ_index("QA_equal_ignore_case", index_type);
131131
const exprt constr2 =
132132
character_equals_ignore_case(s1[qvar], s2[qvar], char_a, char_A, char_Z);
133133
const string_constraintt a2(qvar, s1.length(), eq, constr2);
134-
axioms.push_back(a2);
134+
constraints.push_back(a2);
135135

136136
const symbol_exprt witness =
137137
fresh_exist_index("witness_unequal_ignore_case", index_type);
@@ -147,7 +147,7 @@ exprt string_constraint_generatort::add_axioms_for_equals_ignore_case(
147147
or_exprt(
148148
notequal_exprt(s1.length(), s2.length()),
149149
and_exprt(bound_witness, witness_diff)));
150-
axioms.push_back(a3);
150+
lemmas.push_back(a3);
151151

152152
return typecast_exprt(eq, f.type());
153153
}
@@ -183,7 +183,7 @@ exprt string_constraint_generatort::add_axioms_for_hash_code(
183183
and_exprt(
184184
notequal_exprt(str[i], it.first[i]),
185185
and_exprt(str.axiom_for_length_gt(i), axiom_for_is_positive_index(i))));
186-
axioms.push_back(or_exprt(c1, or_exprt(c2, c3)));
186+
lemmas.push_back(or_exprt(c1, or_exprt(c2, c3)));
187187
}
188188
return hash;
189189
}
@@ -220,12 +220,12 @@ exprt string_constraint_generatort::add_axioms_for_compare_to(
220220

221221
const equal_exprt res_null(res, from_integer(0, return_type));
222222
const implies_exprt a1(res_null, equal_exprt(s1.length(), s2.length()));
223-
axioms.push_back(a1);
223+
lemmas.push_back(a1);
224224

225225
const symbol_exprt i = fresh_univ_index("QA_compare_to", index_type);
226226
const string_constraintt a2(
227227
i, s1.length(), res_null, equal_exprt(s1[i], s2[i]));
228-
axioms.push_back(a2);
228+
constraints.push_back(a2);
229229

230230
const symbol_exprt x = fresh_exist_index("index_compare_to", index_type);
231231
const equal_exprt ret_char_diff(
@@ -251,12 +251,12 @@ exprt string_constraint_generatort::add_axioms_for_compare_to(
251251
and_exprt(
252252
binary_relation_exprt(x, ID_ge, from_integer(0, return_type)),
253253
or_exprt(cond1, cond2)));
254-
axioms.push_back(a3);
254+
lemmas.push_back(a3);
255255

256256
const symbol_exprt i2 = fresh_univ_index("QA_compare_to", index_type);
257257
const string_constraintt a4(
258258
i2, x, not_exprt(res_null), equal_exprt(s1[i2], s2[i2]));
259-
axioms.push_back(a4);
259+
constraints.push_back(a4);
260260

261261
return res;
262262
}
@@ -287,14 +287,14 @@ symbol_exprt string_constraint_generatort::add_axioms_for_intern(
287287
exprt::operandst disj;
288288
for(auto it : intern_of_string)
289289
disj.push_back(equal_exprt(intern, it.second));
290-
axioms.push_back(disjunction(disj));
290+
lemmas.push_back(disjunction(disj));
291291

292292
// WARNING: the specification may be incomplete or incorrect
293293
for(auto it : intern_of_string)
294294
if(it.second!=str)
295295
{
296296
symbol_exprt i=fresh_exist_index("index_intern", index_type);
297-
axioms.push_back(
297+
lemmas.push_back(
298298
or_exprt(
299299
equal_exprt(it.second, intern),
300300
or_exprt(

‎src/solvers/refinement/string_constraint_generator_concat.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -49,20 +49,20 @@ exprt string_constraint_generatort::add_axioms_for_concat_substr(
4949
exprt res_length=plus_exprt_with_overflow_check(
5050
s1.length(), minus_exprt(end_index, start_index));
5151
implies_exprt a1(prem, equal_exprt(res.length(), res_length));
52-
axioms.push_back(a1);
52+
lemmas.push_back(a1);
5353

5454
implies_exprt a2(not_exprt(prem), equal_exprt(res.length(), s1.length()));
55-
axioms.push_back(a2);
55+
lemmas.push_back(a2);
5656

5757
symbol_exprt idx=fresh_univ_index("QA_index_concat", res.length().type());
5858
string_constraintt a3(idx, s1.length(), equal_exprt(s1[idx], res[idx]));
59-
axioms.push_back(a3);
59+
constraints.push_back(a3);
6060

6161
symbol_exprt idx2=fresh_univ_index("QA_index_concat2", res.length().type());
6262
equal_exprt res_eq(
6363
res[plus_exprt(idx2, s1.length())], s2[plus_exprt(start_index, idx2)]);
6464
string_constraintt a4(idx2, minus_exprt(end_index, start_index), res_eq);
65-
axioms.push_back(a4);
65+
constraints.push_back(a4);
6666

6767
// We should have a enum type for the possible error codes
6868
return from_integer(0, res.length().type());
@@ -87,14 +87,14 @@ exprt string_constraint_generatort::add_axioms_for_concat_char(
8787
const typet &index_type = res.length().type();
8888
const equal_exprt a1(
8989
res.length(), plus_exprt(s1.length(), from_integer(1, index_type)));
90-
axioms.push_back(a1);
90+
lemmas.push_back(a1);
9191

9292
symbol_exprt idx = fresh_univ_index("QA_index_concat_char", index_type);
9393
string_constraintt a2(idx, s1.length(), equal_exprt(s1[idx], res[idx]));
94-
axioms.push_back(a2);
94+
constraints.push_back(a2);
9595

9696
equal_exprt a3(res[s1.length()], c);
97-
axioms.push_back(a3);
97+
lemmas.push_back(a3);
9898

9999
// We should have a enum type for the possible error codes
100100
return from_integer(0, get_return_code_type());

‎src/solvers/refinement/string_constraint_generator_constants.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -45,12 +45,12 @@ exprt string_constraint_generatort::add_axioms_for_constant(
4545
const exprt idx = from_integer(i, index_type);
4646
const exprt c = from_integer(str[i], char_type);
4747
const equal_exprt lemma(res[idx], c);
48-
axioms.push_back(implies_exprt(guard, lemma));
48+
lemmas.push_back(implies_exprt(guard, lemma));
4949
}
5050

5151
const exprt s_length = from_integer(str.size(), index_type);
5252

53-
axioms.push_back(implies_exprt(guard, equal_exprt(res.length(), s_length)));
53+
lemmas.push_back(implies_exprt(guard, equal_exprt(res.length(), s_length)));
5454
return from_integer(0, get_return_code_type());
5555
}
5656

@@ -63,7 +63,7 @@ exprt string_constraint_generatort::add_axioms_for_empty_string(
6363
{
6464
PRECONDITION(f.arguments().size() == 2);
6565
exprt length = f.arguments()[0];
66-
axioms.push_back(equal_exprt(length, from_integer(0, length.type())));
66+
lemmas.push_back(equal_exprt(length, from_integer(0, length.type())));
6767
return from_integer(0, get_return_code_type());
6868
}
6969

‎src/solvers/refinement/string_constraint_generator_float.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -251,7 +251,7 @@ exprt string_constraint_generatort::add_axioms_for_fractional_part(
251251

252252
and_exprt a1(res.axiom_for_length_gt(1),
253253
res.axiom_for_length_le(max));
254-
axioms.push_back(a1);
254+
lemmas.push_back(a1);
255255

256256
equal_exprt starts_with_dot(res[0], from_integer('.', char_type));
257257

@@ -289,10 +289,10 @@ exprt string_constraint_generatort::add_axioms_for_fractional_part(
289289
}
290290

291291
exprt a2=conjunction(digit_constraints);
292-
axioms.push_back(a2);
292+
lemmas.push_back(a2);
293293

294294
equal_exprt a3(int_expr, sum);
295-
axioms.push_back(a3);
295+
lemmas.push_back(a3);
296296

297297
return from_integer(0, signedbv_typet(32));
298298
}

0 commit comments

Comments
 (0)