Head

GCC Code Coverage Report

Directory:	.		Exec	Total	Coverage
File:	src/util/result.cpp	Lines:	124	198	62.6 %
Date:	2021-05-21	Branches:	79	228	34.6 %


/******************************************************************************
 * Top contributors (to current version):
 *   Aina Niemetz, Morgan Deters, Tim King
 *
 * This file is part of the cvc5 project.
 *
 * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
 * in the top-level source directory and their institutional affiliations.
 * All rights reserved.  See the file COPYING in the top-level source
 * directory for licensing information.
 * ****************************************************************************
 *
 * Encapsulation of the result of a query.
 */
#include "util/result.h"

#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <string>

#include "base/check.h"
#include "options/set_language.h"

using namespace std;

namespace cvc5 {

Result::Result()
    : d_sat(SAT_UNKNOWN),
      d_entailment(ENTAILMENT_UNKNOWN),
      d_which(TYPE_NONE),
      d_unknownExplanation(UNKNOWN_REASON),
      d_inputName("")
{
}

Result::Result(enum Sat s, std::string inputName)
    : d_sat(s),
      d_entailment(ENTAILMENT_UNKNOWN),
      d_which(TYPE_SAT),
      d_unknownExplanation(UNKNOWN_REASON),
      d_inputName(inputName)
{
  PrettyCheckArgument(s != SAT_UNKNOWN,
                      "Must provide a reason for satisfiability being unknown");
}

Result::Result(enum Entailment e, std::string inputName)
    : d_sat(SAT_UNKNOWN),
      d_entailment(e),
      d_which(TYPE_ENTAILMENT),
      d_unknownExplanation(UNKNOWN_REASON),
      d_inputName(inputName)
{
  PrettyCheckArgument(e != ENTAILMENT_UNKNOWN,
                      "Must provide a reason for entailment being unknown");
}

Result::Result(enum Sat s,
               enum UnknownExplanation unknownExplanation,
               std::string inputName)
    : d_sat(s),
      d_entailment(ENTAILMENT_UNKNOWN),
      d_which(TYPE_SAT),
      d_unknownExplanation(unknownExplanation),
      d_inputName(inputName)
{
  PrettyCheckArgument(s == SAT_UNKNOWN,
                      "improper use of unknown-result constructor");
}

Result::Result(enum Entailment e,
               enum UnknownExplanation unknownExplanation,
               std::string inputName)
    : d_sat(SAT_UNKNOWN),
      d_entailment(e),
      d_which(TYPE_ENTAILMENT),
      d_unknownExplanation(unknownExplanation),
      d_inputName(inputName)
{
  PrettyCheckArgument(e == ENTAILMENT_UNKNOWN,
                      "improper use of unknown-result constructor");
}

Result::Result(const std::string& instr, std::string inputName)
    : d_sat(SAT_UNKNOWN),
      d_entailment(ENTAILMENT_UNKNOWN),
      d_which(TYPE_NONE),
      d_unknownExplanation(UNKNOWN_REASON),
      d_inputName(inputName)
{
  string s = instr;
  transform(s.begin(), s.end(), s.begin(), ::tolower);
  if (s == "sat" || s == "satisfiable") {
    d_which = TYPE_SAT;
    d_sat = SAT;
  } else if (s == "unsat" || s == "unsatisfiable") {
    d_which = TYPE_SAT;
    d_sat = UNSAT;
  }
  else if (s == "entailed")
  {
    d_which = TYPE_ENTAILMENT;
    d_entailment = ENTAILED;
  }
  else if (s == "not_entailed")
  {
    d_which = TYPE_ENTAILMENT;
    d_entailment = NOT_ENTAILED;
  }
  else if (s == "incomplete")
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
    d_unknownExplanation = INCOMPLETE;
  }
  else if (s == "timeout")
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
    d_unknownExplanation = TIMEOUT;
  }
  else if (s == "resourceout")
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
    d_unknownExplanation = RESOURCEOUT;
  }
  else if (s == "memout")
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
    d_unknownExplanation = MEMOUT;
  }
  else if (s == "interrupted")
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
    d_unknownExplanation = INTERRUPTED;
  }
  else if (s.size() >= 7 && s.compare(0, 7, "unknown") == 0)
  {
    d_which = TYPE_SAT;
    d_sat = SAT_UNKNOWN;
  }
  else
  {
    IllegalArgument(s,
                    "expected satisfiability/entailment result, "
                    "instead got `%s'",
                    s.c_str());
  }
}

Result::UnknownExplanation Result::whyUnknown() const {
  PrettyCheckArgument(isUnknown(), this,
                      "This result is not unknown, so the reason for "
                      "being unknown cannot be inquired of it");
  return d_unknownExplanation;
}

bool Result::operator==(const Result& r) const {
  if (d_which != r.d_which) {
    return false;
  }
  if (d_which == TYPE_SAT) {
    return d_sat == r.d_sat && (d_sat != SAT_UNKNOWN ||
                                d_unknownExplanation == r.d_unknownExplanation);
  }
  if (d_which == TYPE_ENTAILMENT)
  {
    return d_entailment == r.d_entailment
           && (d_entailment != ENTAILMENT_UNKNOWN
               || d_unknownExplanation == r.d_unknownExplanation);
  }
  return false;
}

bool operator==(enum Result::Sat sr, const Result& r) { return r == sr; }

bool operator==(enum Result::Entailment e, const Result& r) { return r == e; }
bool operator!=(enum Result::Sat s, const Result& r) { return !(s == r); }
bool operator!=(enum Result::Entailment e, const Result& r)
{
  return !(e == r);
}

Result Result::asSatisfiabilityResult() const {
  if (d_which == TYPE_SAT) {
    return *this;
  }

  if (d_which == TYPE_ENTAILMENT)
  {
    switch (d_entailment)
    {
      case NOT_ENTAILED: return Result(SAT, d_inputName);

      case ENTAILED: return Result(UNSAT, d_inputName);

      case ENTAILMENT_UNKNOWN:
        return Result(SAT_UNKNOWN, d_unknownExplanation, d_inputName);

      default: Unhandled() << d_entailment;
    }
  }

  // TYPE_NONE
  return Result(SAT_UNKNOWN, NO_STATUS, d_inputName);
}

Result Result::asEntailmentResult() const
{
  if (d_which == TYPE_ENTAILMENT)
  {
    return *this;
  }

  if (d_which == TYPE_SAT) {
    switch (d_sat) {
      case SAT: return Result(NOT_ENTAILED, d_inputName);

      case UNSAT: return Result(ENTAILED, d_inputName);

      case SAT_UNKNOWN:
        return Result(ENTAILMENT_UNKNOWN, d_unknownExplanation, d_inputName);

      default: Unhandled() << d_sat;
    }
  }

  // TYPE_NONE
  return Result(ENTAILMENT_UNKNOWN, NO_STATUS, d_inputName);
}

string Result::toString() const {
  stringstream ss;
  ss << *this;
  return ss.str();
}

ostream& operator<<(ostream& out, enum Result::Sat s) {
  switch (s) {
    case Result::UNSAT:
      out << "UNSAT";
      break;
    case Result::SAT:
      out << "SAT";
      break;
    case Result::SAT_UNKNOWN:
      out << "SAT_UNKNOWN";
      break;
    default: Unhandled() << s;
  }
  return out;
}

ostream& operator<<(ostream& out, enum Result::Entailment e)
{
  switch (e)
  {
    case Result::NOT_ENTAILED: out << "NOT_ENTAILED"; break;
    case Result::ENTAILED: out << "ENTAILED"; break;
    case Result::ENTAILMENT_UNKNOWN: out << "ENTAILMENT_UNKNOWN"; break;
    default: Unhandled() << e;
  }
  return out;
}

ostream& operator<<(ostream& out, enum Result::UnknownExplanation e)
{
  switch (e)
  {
    case Result::REQUIRES_FULL_CHECK: out << "REQUIRES_FULL_CHECK"; break;
    case Result::INCOMPLETE: out << "INCOMPLETE"; break;
    case Result::TIMEOUT: out << "TIMEOUT"; break;
    case Result::RESOURCEOUT: out << "RESOURCEOUT"; break;
    case Result::MEMOUT: out << "MEMOUT"; break;
    case Result::INTERRUPTED: out << "INTERRUPTED"; break;
    case Result::NO_STATUS: out << "NO_STATUS"; break;
    case Result::UNSUPPORTED: out << "UNSUPPORTED"; break;
    case Result::OTHER: out << "OTHER"; break;
    case Result::UNKNOWN_REASON: out << "UNKNOWN_REASON"; break;
    default: Unhandled() << e;
  }
  return out;
}

ostream& operator<<(ostream& out, const Result& r) {
  r.toStream(out, language::SetLanguage::getLanguage(out));
  return out;
} /* operator<<(ostream&, const Result&) */

void Result::toStreamDefault(std::ostream& out) const {
  if (getType() == Result::TYPE_SAT) {
    switch (isSat()) {
      case Result::UNSAT:
        out << "unsat";
        break;
      case Result::SAT:
        out << "sat";
        break;
      case Result::SAT_UNKNOWN:
        out << "unknown";
        if (whyUnknown() != Result::UNKNOWN_REASON) {
          out << " (" << whyUnknown() << ")";
        }
        break;
    }
  } else {
    switch (isEntailed())
    {
      case Result::NOT_ENTAILED: out << "not_entailed"; break;
      case Result::ENTAILED: out << "entailed"; break;
      case Result::ENTAILMENT_UNKNOWN:
        out << "unknown";
        if (whyUnknown() != Result::UNKNOWN_REASON) {
          out << " (" << whyUnknown() << ")";
        }
        break;
    }
  }
} /* Result::toStreamDefault() */

void Result::toStreamSmt2(ostream& out) const {
  if (getType() == Result::TYPE_SAT && isSat() == Result::SAT_UNKNOWN) {
    out << "unknown";
  } else {
    toStreamDefault(out);
  }
}

void Result::toStreamTptp(std::ostream& out) const {
  out << "% SZS status ";
  if (isSat() == Result::SAT) {
    out << "Satisfiable";
  } else if (isSat() == Result::UNSAT) {
    out << "Unsatisfiable";
  }
  else if (isEntailed() == Result::ENTAILED)
  {
    out << "Theorem";
  }
  else if (isEntailed() == Result::NOT_ENTAILED)
  {
    out << "CounterSatisfiable";
  }
  else
  {
    out << "GaveUp";
  }
  out << " for " << getInputName();
}

void Result::toStream(std::ostream& out, OutputLanguage language) const {
  switch (language) {
    case language::output::LANG_SYGUS_V2: toStreamSmt2(out); break;
    case language::output::LANG_TPTP:
      toStreamTptp(out);
      break;
    default:
      if (language::isOutputLang_smt2(language))
      {
        toStreamSmt2(out);
      }
      else
      {
        toStreamDefault(out);
      }
      break;
  };
}

}  // namespace cvc5


Generated by: GCOVR (Version 3.2)

Line	Exec	Source
1		/******************************************************************************
2		* Top contributors (to current version):
3		* Aina Niemetz, Morgan Deters, Tim King
4		*
5		* This file is part of the cvc5 project.
6		*
7		* Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
8		* in the top-level source directory and their institutional affiliations.
9		* All rights reserved. See the file COPYING in the top-level source
10		* directory for licensing information.
11		* ****************************************************************************
12		*
13		* Encapsulation of the result of a query.
14		*/
15		#include "util/result.h"
16
17		#include <algorithm>
18		#include <cctype>
19		#include <iostream>
20		#include <sstream>
21		#include <string>
22
23		#include "base/check.h"
24		#include "options/set_language.h"
25
26		using namespace std;
27
28		namespace cvc5 {
29
30	348479	Result::Result()
31		: d_sat(SAT_UNKNOWN),
32		d_entailment(ENTAILMENT_UNKNOWN),
33		d_which(TYPE_NONE),
34		d_unknownExplanation(UNKNOWN_REASON),
35	348479	d_inputName("")
36		{
37	348479	}
38
39	13019	Result::Result(enum Sat s, std::string inputName)
40		: d_sat(s),
41		d_entailment(ENTAILMENT_UNKNOWN),
42		d_which(TYPE_SAT),
43		d_unknownExplanation(UNKNOWN_REASON),
44	13019	d_inputName(inputName)
45		{
46	13019	PrettyCheckArgument(s != SAT_UNKNOWN,
47		"Must provide a reason for satisfiability being unknown");
48	13019	}
49
50	570	Result::Result(enum Entailment e, std::string inputName)
51		: d_sat(SAT_UNKNOWN),
52		d_entailment(e),
53		d_which(TYPE_ENTAILMENT),
54		d_unknownExplanation(UNKNOWN_REASON),
55	570	d_inputName(inputName)
56		{
57	570	PrettyCheckArgument(e != ENTAILMENT_UNKNOWN,
58		"Must provide a reason for entailment being unknown");
59	570	}
60
61	13339	Result::Result(enum Sat s,
62		enum UnknownExplanation unknownExplanation,
63	13339	std::string inputName)
64		: d_sat(s),
65		d_entailment(ENTAILMENT_UNKNOWN),
66		d_which(TYPE_SAT),
67		d_unknownExplanation(unknownExplanation),
68	13339	d_inputName(inputName)
69		{
70	13339	PrettyCheckArgument(s == SAT_UNKNOWN,
71		"improper use of unknown-result constructor");
72	13339	}
73
74	85844	Result::Result(enum Entailment e,
75		enum UnknownExplanation unknownExplanation,
76	85844	std::string inputName)
77		: d_sat(SAT_UNKNOWN),
78		d_entailment(e),
79		d_which(TYPE_ENTAILMENT),
80		d_unknownExplanation(unknownExplanation),
81	85844	d_inputName(inputName)
82		{
83	85844	PrettyCheckArgument(e == ENTAILMENT_UNKNOWN,
84		"improper use of unknown-result constructor");
85	85844	}
86
87	3484	Result::Result(const std::string& instr, std::string inputName)
88		: d_sat(SAT_UNKNOWN),
89		d_entailment(ENTAILMENT_UNKNOWN),
90		d_which(TYPE_NONE),
91		d_unknownExplanation(UNKNOWN_REASON),
92	3484	d_inputName(inputName)
93		{
94	6968	string s = instr;
95	3484	transform(s.begin(), s.end(), s.begin(), ::tolower);
96	3484	if (s == "sat" \|\| s == "satisfiable") {
97	1426	d_which = TYPE_SAT;
98	1426	d_sat = SAT;
99	2058	} else if (s == "unsat" \|\| s == "unsatisfiable") {
100	2019	d_which = TYPE_SAT;
101	2019	d_sat = UNSAT;
102		}
103	39	else if (s == "entailed")
104		{
105		d_which = TYPE_ENTAILMENT;
106		d_entailment = ENTAILED;
107		}
108	39	else if (s == "not_entailed")
109		{
110		d_which = TYPE_ENTAILMENT;
111		d_entailment = NOT_ENTAILED;
112		}
113	39	else if (s == "incomplete")
114		{
115		d_which = TYPE_SAT;
116		d_sat = SAT_UNKNOWN;
117		d_unknownExplanation = INCOMPLETE;
118		}
119	39	else if (s == "timeout")
120		{
121		d_which = TYPE_SAT;
122		d_sat = SAT_UNKNOWN;
123		d_unknownExplanation = TIMEOUT;
124		}
125	39	else if (s == "resourceout")
126		{
127		d_which = TYPE_SAT;
128		d_sat = SAT_UNKNOWN;
129		d_unknownExplanation = RESOURCEOUT;
130		}
131	39	else if (s == "memout")
132		{
133		d_which = TYPE_SAT;
134		d_sat = SAT_UNKNOWN;
135		d_unknownExplanation = MEMOUT;
136		}
137	39	else if (s == "interrupted")
138		{
139		d_which = TYPE_SAT;
140		d_sat = SAT_UNKNOWN;
141		d_unknownExplanation = INTERRUPTED;
142		}
143	39	else if (s.size() >= 7 && s.compare(0, 7, "unknown") == 0)
144		{
145	39	d_which = TYPE_SAT;
146	39	d_sat = SAT_UNKNOWN;
147		}
148		else
149		{
150		IllegalArgument(s,
151		"expected satisfiability/entailment result, "
152		"instead got `%s'",
153		s.c_str());
154		}
155	3484	}
156
157	12	Result::UnknownExplanation Result::whyUnknown() const {
158	12	PrettyCheckArgument(isUnknown(), this,
159		"This result is not unknown, so the reason for "
160		"being unknown cannot be inquired of it");
161	12	return d_unknownExplanation;
162		}
163
164	3578	bool Result::operator==(const Result& r) const {
165	3578	if (d_which != r.d_which) {
166		return false;
167		}
168	3578	if (d_which == TYPE_SAT) {
169	3578	return d_sat == r.d_sat && (d_sat != SAT_UNKNOWN \|\|
170	3578	d_unknownExplanation == r.d_unknownExplanation);
171		}
172		if (d_which == TYPE_ENTAILMENT)
173		{
174		return d_entailment == r.d_entailment
175		&& (d_entailment != ENTAILMENT_UNKNOWN
176		\|\| d_unknownExplanation == r.d_unknownExplanation);
177		}
178		return false;
179		}
180
181		bool operator==(enum Result::Sat sr, const Result& r) { return r == sr; }
182
183		bool operator==(enum Result::Entailment e, const Result& r) { return r == e; }
184		bool operator!=(enum Result::Sat s, const Result& r) { return !(s == r); }
185		bool operator!=(enum Result::Entailment e, const Result& r)
186		{
187		return !(e == r);
188		}
189
190	23041	Result Result::asSatisfiabilityResult() const {
191	23041	if (d_which == TYPE_SAT) {
192	23039	return *this;
193		}
194
195	2	if (d_which == TYPE_ENTAILMENT)
196		{
197		switch (d_entailment)
198		{
199		case NOT_ENTAILED: return Result(SAT, d_inputName);
200
201		case ENTAILED: return Result(UNSAT, d_inputName);
202
203		case ENTAILMENT_UNKNOWN:
204		return Result(SAT_UNKNOWN, d_unknownExplanation, d_inputName);
205
206		default: Unhandled() << d_entailment;
207		}
208		}
209
210		// TYPE_NONE
211	2	return Result(SAT_UNKNOWN, NO_STATUS, d_inputName);
212		}
213
214	86414	Result Result::asEntailmentResult() const
215		{
216	86414	if (d_which == TYPE_ENTAILMENT)
217		{
218	85841	return *this;
219		}
220
221	573	if (d_which == TYPE_SAT) {
222	573	switch (d_sat) {
223	184	case SAT: return Result(NOT_ENTAILED, d_inputName);
224
225	386	case UNSAT: return Result(ENTAILED, d_inputName);
226
227	3	case SAT_UNKNOWN:
228	3	return Result(ENTAILMENT_UNKNOWN, d_unknownExplanation, d_inputName);
229
230		default: Unhandled() << d_sat;
231		}
232		}
233
234		// TYPE_NONE
235		return Result(ENTAILMENT_UNKNOWN, NO_STATUS, d_inputName);
236		}
237
238	9401	string Result::toString() const {
239	18802	stringstream ss;
240	9401	ss << *this;
241	18802	return ss.str();
242		}
243
244		ostream& operator<<(ostream& out, enum Result::Sat s) {
245		switch (s) {
246		case Result::UNSAT:
247		out << "UNSAT";
248		break;
249		case Result::SAT:
250		out << "SAT";
251		break;
252		case Result::SAT_UNKNOWN:
253		out << "SAT_UNKNOWN";
254		break;
255		default: Unhandled() << s;
256		}
257		return out;
258		}
259
260		ostream& operator<<(ostream& out, enum Result::Entailment e)
261		{
262		switch (e)
263		{
264		case Result::NOT_ENTAILED: out << "NOT_ENTAILED"; break;
265		case Result::ENTAILED: out << "ENTAILED"; break;
266		case Result::ENTAILMENT_UNKNOWN: out << "ENTAILMENT_UNKNOWN"; break;
267		default: Unhandled() << e;
268		}
269		return out;
270		}
271
272	8	ostream& operator<<(ostream& out, enum Result::UnknownExplanation e)
273		{
274	8	switch (e)
275		{
276		case Result::REQUIRES_FULL_CHECK: out << "REQUIRES_FULL_CHECK"; break;
277	8	case Result::INCOMPLETE: out << "INCOMPLETE"; break;
278		case Result::TIMEOUT: out << "TIMEOUT"; break;
279		case Result::RESOURCEOUT: out << "RESOURCEOUT"; break;
280		case Result::MEMOUT: out << "MEMOUT"; break;
281		case Result::INTERRUPTED: out << "INTERRUPTED"; break;
282		case Result::NO_STATUS: out << "NO_STATUS"; break;
283		case Result::UNSUPPORTED: out << "UNSUPPORTED"; break;
284		case Result::OTHER: out << "OTHER"; break;
285		case Result::UNKNOWN_REASON: out << "UNKNOWN_REASON"; break;
286		default: Unhandled() << e;
287		}
288	8	return out;
289		}
290
291	9402	ostream& operator<<(ostream& out, const Result& r) {
292	9402	r.toStream(out, language::SetLanguage::getLanguage(out));
293	9402	return out;
294		} /* operator<<(ostream&, const Result&) */
295
296	9305	void Result::toStreamDefault(std::ostream& out) const {
297	9305	if (getType() == Result::TYPE_SAT) {
298	8779	switch (isSat()) {
299	3735	case Result::UNSAT:
300	3735	out << "unsat";
301	3735	break;
302	5042	case Result::SAT:
303	5042	out << "sat";
304	5042	break;
305	2	case Result::SAT_UNKNOWN:
306	2	out << "unknown";
307	2	if (whyUnknown() != Result::UNKNOWN_REASON) {
308	2	out << " (" << whyUnknown() << ")";
309		}
310	2	break;
311		}
312		} else {
313	526	switch (isEntailed())
314		{
315	172	case Result::NOT_ENTAILED: out << "not_entailed"; break;
316	354	case Result::ENTAILED: out << "entailed"; break;
317		case Result::ENTAILMENT_UNKNOWN:
318		out << "unknown";
319		if (whyUnknown() != Result::UNKNOWN_REASON) {
320		out << " (" << whyUnknown() << ")";
321		}
322		break;
323		}
324		}
325	9305	} /* Result::toStreamDefault() */
326
327	8358	void Result::toStreamSmt2(ostream& out) const {
328	8358	if (getType() == Result::TYPE_SAT && isSat() == Result::SAT_UNKNOWN) {
329	55	out << "unknown";
330		} else {
331	8303	toStreamDefault(out);
332		}
333	8358	}
334
335	42	void Result::toStreamTptp(std::ostream& out) const {
336	42	out << "% SZS status ";
337	42	if (isSat() == Result::SAT) {
338	9	out << "Satisfiable";
339	33	} else if (isSat() == Result::UNSAT) {
340	9	out << "Unsatisfiable";
341		}
342	24	else if (isEntailed() == Result::ENTAILED)
343		{
344	16	out << "Theorem";
345		}
346	8	else if (isEntailed() == Result::NOT_ENTAILED)
347		{
348	6	out << "CounterSatisfiable";
349		}
350		else
351		{
352	2	out << "GaveUp";
353		}
354	42	out << " for " << getInputName();
355	42	}
356
357	9402	void Result::toStream(std::ostream& out, OutputLanguage language) const {
358	9402	switch (language) {
359	181	case language::output::LANG_SYGUS_V2: toStreamSmt2(out); break;
360	42	case language::output::LANG_TPTP:
361	42	toStreamTptp(out);
362	42	break;
363	9179	default:
364	9179	if (language::isOutputLang_smt2(language))
365		{
366	8177	toStreamSmt2(out);
367		}
368		else
369		{
370	1002	toStreamDefault(out);
371		}
372	9179	break;
373		};
374	9402	}
375
376	27735	} // namespace cvc5