Head

GCC Code Coverage Report

Directory:	.		Exec	Total	Coverage
File:	src/base/configuration.cpp	Lines:	109	143	76.2 %
Date:	2021-08-03	Branches:	117	292	40.1 %


/******************************************************************************
 * Top contributors (to current version):
 *   Morgan Deters, Aina Niemetz, Mathias Preiner
 *
 * 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.
 * ****************************************************************************
 *
 * Implementation of Configuration class, which provides compile-time
 * configuration information about the cvc5 library.
 */
#include "base/configuration.h"

#include <stdlib.h>
#include <string.h>

#include <sstream>
#include <string>

#include "base/configuration_private.h"
#include "base/cvc5config.h"

#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
#  include "base/Debug_tags.h"
#endif /* CVC5_DEBUG && CVC5_TRACING */

#ifdef CVC5_TRACING
#  include "base/Trace_tags.h"
#endif /* CVC5_TRACING */

using namespace std;

namespace cvc5 {

string Configuration::getName() { return CVC5_PACKAGE_NAME; }

bool Configuration::isDebugBuild() {
  return IS_DEBUG_BUILD;
}

bool Configuration::isTracingBuild() {
  return IS_TRACING_BUILD;
}

bool Configuration::isDumpingBuild() {
  return IS_DUMPING_BUILD && !IS_MUZZLED_BUILD;
}

bool Configuration::isMuzzledBuild() {
  return IS_MUZZLED_BUILD;
}

bool Configuration::isAssertionBuild() {
  return IS_ASSERTIONS_BUILD;
}

bool Configuration::isCoverageBuild() {
  return IS_COVERAGE_BUILD;
}

bool Configuration::isProfilingBuild() {
  return IS_PROFILING_BUILD;
}

bool Configuration::isAsanBuild() { return IS_ASAN_BUILD; }

bool Configuration::isUbsanBuild() { return IS_UBSAN_BUILD; }

bool Configuration::isTsanBuild() { return IS_TSAN_BUILD; }

bool Configuration::isCompetitionBuild() {
  return IS_COMPETITION_BUILD;
}

bool Configuration::isStaticBuild()
{
#if defined(CVC5_STATIC_BUILD)
  return true;
#else
  return false;
#endif
}

string Configuration::getPackageName() { return CVC5_PACKAGE_NAME; }

string Configuration::getVersionString() { return CVC5_RELEASE_STRING; }

unsigned Configuration::getVersionMajor() { return CVC5_MAJOR; }

unsigned Configuration::getVersionMinor() { return CVC5_MINOR; }

unsigned Configuration::getVersionRelease() { return CVC5_RELEASE; }

std::string Configuration::getVersionExtra() { return CVC5_EXTRAVERSION; }

std::string Configuration::copyright() {
  std::stringstream ss;
  ss << "Copyright (c) 2009-2021 by the authors and their institutional\n"
     << "affiliations listed at https://cvc5.github.io/people.html\n\n";

  if (Configuration::licenseIsGpl()) {
    ss << "This build of cvc5 uses GPLed libraries, and is thus covered by\n"
       << "the GNU General Public License (GPL) version 3.  Versions of cvc5\n"
       << "are available that are covered by the (modified) BSD license. If\n"
       << "you want to license cvc5 under this license, please configure cvc5\n"
       << "with the \"--no-gpl\" option before building from sources.\n\n";
  } else {
    ss << "cvc5 is open-source and is covered by the BSD license (modified)."
       << "\n\n";
  }

  ss << "THIS SOFTWARE IS PROVIDED AS-IS, WITHOUT ANY WARRANTIES.\n"
     << "USE AT YOUR OWN RISK.\n\n";

  ss << "cvc5 incorporates code from ANTLR3 (http://www.antlr.org).\n"
     << "See licenses/antlr3-LICENSE for copyright and licensing information."
     << "\n\n";

  ss << "This version of cvc5 is linked against the following non-(L)GPL'ed\n"
     << "third party libraries.\n\n";

  ss << "  CaDiCaL - Simplified Satisfiability Solver\n"
     << "  See https://github.com/arminbiere/cadical for copyright "
     << "information.\n\n";

  if (Configuration::isBuiltWithAbc()
      || Configuration::isBuiltWithCryptominisat()
      || Configuration::isBuiltWithKissat()
      || Configuration::isBuiltWithEditline())
  {
    if (Configuration::isBuiltWithAbc()) {
      ss << "  ABC - A System for Sequential Synthesis and Verification\n"
         << "  See http://bitbucket.org/alanmi/abc for copyright and\n"
         << "  licensing information.\n\n";
    }
    if (Configuration::isBuiltWithCryptominisat())
    {
      ss << "  CryptoMiniSat - An Advanced SAT Solver\n"
         << "  See https://github.com/msoos/cryptominisat for copyright "
         << "information.\n\n";
    }
    if (Configuration::isBuiltWithKissat())
    {
      ss << "  Kissat - Simplified Satisfiability Solver\n"
         << "  See https://fmv.jku.at/kissat for copyright "
         << "information.\n\n";
    }
    if (Configuration::isBuiltWithEditline())
    {
      ss << "  Editline Library\n"
         << "  See https://thrysoee.dk/editline\n"
         << "  for copyright information.\n\n";
    }
  }

  ss << "  SymFPU - The Symbolic Floating Point Unit\n"
     << "  See https://github.com/martin-cs/symfpu/tree/cvc5 for copyright "
     << "information.\n\n";

  if (Configuration::isBuiltWithGmp() || Configuration::isBuiltWithPoly())
  {
    ss << "This version of cvc5 is linked against the following third party\n"
       << "libraries covered by the LGPLv3 license.\n"
       << "See licenses/lgpl-3.0.txt for more information.\n\n";
    if (Configuration::isBuiltWithGmp()) {
      ss << "  GMP - Gnu Multi Precision Arithmetic Library\n"
         << "  See http://gmplib.org for copyright information.\n\n";
    }
    if (Configuration::isBuiltWithPoly())
    {
      ss << "  LibPoly polynomial library\n"
         << "  See https://github.com/SRI-CSL/libpoly for copyright and\n"
         << "  licensing information.\n\n";
    }
    if (Configuration::isStaticBuild())
    {
      ss << "cvc5 is statically linked against these libraries. To recompile\n"
            "this version of cvc5 with different versions of these libraries\n"
            "follow the instructions on "
            "https://github.com/cvc5/cvc5/blob/master/INSTALL.md\n\n";
    }
  }

  if (Configuration::isBuiltWithCln()
      || Configuration::isBuiltWithGlpk ()) {
    ss << "This version of cvc5 is linked against the following third party\n"
       << "libraries covered by the GPLv3 license.\n"
       << "See licenses/gpl-3.0.txt for more information.\n\n";
    if (Configuration::isBuiltWithCln()) {
      ss << "  CLN - Class Library for Numbers\n"
         << "  See http://www.ginac.de/CLN for copyright information.\n\n";
    }
    if (Configuration::isBuiltWithGlpk()) {
      ss << "  glpk-cut-log -  a modified version of GPLK, "
         << "the GNU Linear Programming Kit\n"
         << "  See http://github.com/timothy-king/glpk-cut-log for copyright"
         << "information\n\n";
    }
  }

  ss << "See the file COPYING (distributed with the source code, and with\n"
     << "all binaries) for the full cvc5 copyright, licensing, and (lack of)\n"
     << "warranty information.\n";
  return ss.str();
}

std::string Configuration::about() {
  std::stringstream ss;
  ss << "This is cvc5 version " << CVC5_RELEASE_STRING;
  if (Configuration::isGitBuild()) {
    ss << " [" << Configuration::getGitId() << "]";
  }
  ss << "\ncompiled with " << Configuration::getCompiler()
     << "\non " << Configuration::getCompiledDateTime() << "\n\n";
  ss << Configuration::copyright ();
  return ss.str();
}

bool Configuration::licenseIsGpl() {
  return IS_GPL_BUILD;
}

bool Configuration::isBuiltWithGmp() {
  return IS_GMP_BUILD;
}

bool Configuration::isBuiltWithCln() {
  return IS_CLN_BUILD;
}

bool Configuration::isBuiltWithGlpk() {
  return IS_GLPK_BUILD;
}

bool Configuration::isBuiltWithAbc() {
  return IS_ABC_BUILD;
}

bool Configuration::isBuiltWithCryptominisat() {
  return IS_CRYPTOMINISAT_BUILD;
}

bool Configuration::isBuiltWithKissat() { return IS_KISSAT_BUILD; }

bool Configuration::isBuiltWithEditline() { return IS_EDITLINE_BUILD; }

bool Configuration::isBuiltWithPoly()
{
  return IS_POLY_BUILD;
}

unsigned Configuration::getNumDebugTags() {
#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
  /* -1 because a NULL pointer is inserted as the last value */
  return (sizeof(Debug_tags) / sizeof(Debug_tags[0])) - 1;
#else  /* CVC5_DEBUG && CVC5_TRACING */
  return 0;
#endif /* CVC5_DEBUG && CVC5_TRACING */
}

char const* const* Configuration::getDebugTags() {
#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
  return Debug_tags;
#else  /* CVC5_DEBUG && CVC5_TRACING */
  static char const* no_tags[] = { NULL };
  return no_tags;
#endif /* CVC5_DEBUG && CVC5_TRACING */
}

int strcmpptr(const char **s1, const char **s2){
  return strcmp(*s1,*s2);
}

bool Configuration::isDebugTag(char const *tag){
#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
  unsigned ntags = getNumDebugTags();
  char const* const* tags = getDebugTags();
  for (unsigned i = 0; i < ntags; ++ i) {
    if (strcmp(tag, tags[i]) == 0) {
      return true;
    }
  }
#endif /* CVC5_DEBUG && CVC5_TRACING */
  return false;
}

unsigned Configuration::getNumTraceTags() {
#if CVC5_TRACING
  /* -1 because a NULL pointer is inserted as the last value */
  return sizeof(Trace_tags) / sizeof(Trace_tags[0]) - 1;
#else  /* CVC5_TRACING */
  return 0;
#endif /* CVC5_TRACING */
}

char const* const* Configuration::getTraceTags() {
#if CVC5_TRACING
  return Trace_tags;
#else  /* CVC5_TRACING */
  static char const* no_tags[] = { NULL };
  return no_tags;
#endif /* CVC5_TRACING */
}

bool Configuration::isTraceTag(char const * tag){
#if CVC5_TRACING
  unsigned ntags = getNumTraceTags();
  char const* const* tags = getTraceTags();
  for (unsigned i = 0; i < ntags; ++ i) {
    if (strcmp(tag, tags[i]) == 0) {
      return true;
    }
  }
#endif /* CVC5_TRACING */
  return false;
}

bool Configuration::isGitBuild() {
  return IS_GIT_BUILD;
}

const char* Configuration::getGitBranchName() {
  return GIT_BRANCH_NAME;
}

const char* Configuration::getGitCommit() {
  return GIT_COMMIT;
}

bool Configuration::hasGitModifications() {
  return GIT_HAS_MODIFICATIONS;
}

std::string Configuration::getGitId() {
  if(! isGitBuild()) {
    return "";
  }

  const char* branchName = getGitBranchName();
  if(*branchName == '\0') {
    branchName = "-";
  }

  stringstream ss;
  ss << "git " << branchName << " " << string(getGitCommit()).substr(0, 8)
     << (::cvc5::Configuration::hasGitModifications() ? " (with modifications)"
                                                      : "");
  return ss.str();
}

std::string Configuration::getCompiler() {
  stringstream ss;
#ifdef __GNUC__
  ss << "GCC";
#else /* __GNUC__ */
  ss << "unknown compiler";
#endif /* __GNUC__ */
#ifdef __VERSION__
  ss << " version " << __VERSION__;
#else /* __VERSION__ */
  ss << ", unknown version";
#endif /* __VERSION__ */
  return ss.str();
}

std::string Configuration::getCompiledDateTime() {
  return __DATE__ " " __TIME__;
}

}  // namespace cvc5


Generated by: GCOVR (Version 3.2)

Line	Exec	Source
1		/******************************************************************************
2		* Top contributors (to current version):
3		* Morgan Deters, Aina Niemetz, Mathias Preiner
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		* Implementation of Configuration class, which provides compile-time
14		* configuration information about the cvc5 library.
15		*/
16		#include "base/configuration.h"
17
18		#include <stdlib.h>
19		#include <string.h>
20
21		#include <sstream>
22		#include <string>
23
24		#include "base/configuration_private.h"
25		#include "base/cvc5config.h"
26
27		#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
28		# include "base/Debug_tags.h"
29		#endif /* CVC5_DEBUG && CVC5_TRACING */
30
31		#ifdef CVC5_TRACING
32		# include "base/Trace_tags.h"
33		#endif /* CVC5_TRACING */
34
35		using namespace std;
36
37		namespace cvc5 {
38
39	3	string Configuration::getName() { return CVC5_PACKAGE_NAME; }
40
41	329169	bool Configuration::isDebugBuild() {
42	329169	return IS_DEBUG_BUILD;
43		}
44
45	2601	bool Configuration::isTracingBuild() {
46	2601	return IS_TRACING_BUILD;
47		}
48
49	2602	bool Configuration::isDumpingBuild() {
50	2602	return IS_DUMPING_BUILD && !IS_MUZZLED_BUILD;
51		}
52
53	8925	bool Configuration::isMuzzledBuild() {
54	8925	return IS_MUZZLED_BUILD;
55		}
56
57	2829551	bool Configuration::isAssertionBuild() {
58	2829551	return IS_ASSERTIONS_BUILD;
59		}
60
61	2601	bool Configuration::isCoverageBuild() {
62	2601	return IS_COVERAGE_BUILD;
63		}
64
65	2601	bool Configuration::isProfilingBuild() {
66	2601	return IS_PROFILING_BUILD;
67		}
68
69	2599	bool Configuration::isAsanBuild() { return IS_ASAN_BUILD; }
70
71	2599	bool Configuration::isUbsanBuild() { return IS_UBSAN_BUILD; }
72
73	2599	bool Configuration::isTsanBuild() { return IS_TSAN_BUILD; }
74
75	2599	bool Configuration::isCompetitionBuild() {
76	2599	return IS_COMPETITION_BUILD;
77		}
78
79	2602	bool Configuration::isStaticBuild()
80		{
81		#if defined(CVC5_STATIC_BUILD)
82	2602	return true;
83		#else
84		return false;
85		#endif
86		}
87
88	2	string Configuration::getPackageName() { return CVC5_PACKAGE_NAME; }
89
90	2602	string Configuration::getVersionString() { return CVC5_RELEASE_STRING; }
91
92	2601	unsigned Configuration::getVersionMajor() { return CVC5_MAJOR; }
93
94	2601	unsigned Configuration::getVersionMinor() { return CVC5_MINOR; }
95
96	2601	unsigned Configuration::getVersionRelease() { return CVC5_RELEASE; }
97
98		std::string Configuration::getVersionExtra() { return CVC5_EXTRAVERSION; }
99
100	2602	std::string Configuration::copyright() {
101	5204	std::stringstream ss;
102		ss << "Copyright (c) 2009-2021 by the authors and their institutional\n"
103	2602	<< "affiliations listed at https://cvc5.github.io/people.html\n\n";
104
105	2602	if (Configuration::licenseIsGpl()) {
106		ss << "This build of cvc5 uses GPLed libraries, and is thus covered by\n"
107		<< "the GNU General Public License (GPL) version 3. Versions of cvc5\n"
108		<< "are available that are covered by the (modified) BSD license. If\n"
109		<< "you want to license cvc5 under this license, please configure cvc5\n"
110	2602	<< "with the \"--no-gpl\" option before building from sources.\n\n";
111		} else {
112		ss << "cvc5 is open-source and is covered by the BSD license (modified)."
113		<< "\n\n";
114		}
115
116		ss << "THIS SOFTWARE IS PROVIDED AS-IS, WITHOUT ANY WARRANTIES.\n"
117	2602	<< "USE AT YOUR OWN RISK.\n\n";
118
119		ss << "cvc5 incorporates code from ANTLR3 (http://www.antlr.org).\n"
120		<< "See licenses/antlr3-LICENSE for copyright and licensing information."
121	2602	<< "\n\n";
122
123		ss << "This version of cvc5 is linked against the following non-(L)GPL'ed\n"
124	2602	<< "third party libraries.\n\n";
125
126		ss << " CaDiCaL - Simplified Satisfiability Solver\n"
127		<< " See https://github.com/arminbiere/cadical for copyright "
128	2602	<< "information.\n\n";
129
130	5204	if (Configuration::isBuiltWithAbc()
131	2602	\|\| Configuration::isBuiltWithCryptominisat()
132		\|\| Configuration::isBuiltWithKissat()
133	2602	\|\| Configuration::isBuiltWithEditline())
134		{
135	2602	if (Configuration::isBuiltWithAbc()) {
136		ss << " ABC - A System for Sequential Synthesis and Verification\n"
137		<< " See http://bitbucket.org/alanmi/abc for copyright and\n"
138		<< " licensing information.\n\n";
139		}
140	2602	if (Configuration::isBuiltWithCryptominisat())
141		{
142		ss << " CryptoMiniSat - An Advanced SAT Solver\n"
143		<< " See https://github.com/msoos/cryptominisat for copyright "
144	2602	<< "information.\n\n";
145		}
146	2602	if (Configuration::isBuiltWithKissat())
147		{
148		ss << " Kissat - Simplified Satisfiability Solver\n"
149		<< " See https://fmv.jku.at/kissat for copyright "
150		<< "information.\n\n";
151		}
152	2602	if (Configuration::isBuiltWithEditline())
153		{
154		ss << " Editline Library\n"
155		<< " See https://thrysoee.dk/editline\n"
156		<< " for copyright information.\n\n";
157		}
158		}
159
160		ss << " SymFPU - The Symbolic Floating Point Unit\n"
161		<< " See https://github.com/martin-cs/symfpu/tree/cvc5 for copyright "
162	2602	<< "information.\n\n";
163
164	2602	if (Configuration::isBuiltWithGmp() \|\| Configuration::isBuiltWithPoly())
165		{
166		ss << "This version of cvc5 is linked against the following third party\n"
167		<< "libraries covered by the LGPLv3 license.\n"
168	2602	<< "See licenses/lgpl-3.0.txt for more information.\n\n";
169	2602	if (Configuration::isBuiltWithGmp()) {
170		ss << " GMP - Gnu Multi Precision Arithmetic Library\n"
171		<< " See http://gmplib.org for copyright information.\n\n";
172		}
173	2602	if (Configuration::isBuiltWithPoly())
174		{
175		ss << " LibPoly polynomial library\n"
176		<< " See https://github.com/SRI-CSL/libpoly for copyright and\n"
177	2602	<< " licensing information.\n\n";
178		}
179	2602	if (Configuration::isStaticBuild())
180		{
181	2602	ss << "cvc5 is statically linked against these libraries. To recompile\n"
182		"this version of cvc5 with different versions of these libraries\n"
183		"follow the instructions on "
184		"https://github.com/cvc5/cvc5/blob/master/INSTALL.md\n\n";
185		}
186		}
187
188	5204	if (Configuration::isBuiltWithCln()
189	2602	\|\| Configuration::isBuiltWithGlpk ()) {
190		ss << "This version of cvc5 is linked against the following third party\n"
191		<< "libraries covered by the GPLv3 license.\n"
192	2602	<< "See licenses/gpl-3.0.txt for more information.\n\n";
193	2602	if (Configuration::isBuiltWithCln()) {
194		ss << " CLN - Class Library for Numbers\n"
195	2602	<< " See http://www.ginac.de/CLN for copyright information.\n\n";
196		}
197	2602	if (Configuration::isBuiltWithGlpk()) {
198		ss << " glpk-cut-log - a modified version of GPLK, "
199		<< "the GNU Linear Programming Kit\n"
200		<< " See http://github.com/timothy-king/glpk-cut-log for copyright"
201		<< "information\n\n";
202		}
203		}
204
205		ss << "See the file COPYING (distributed with the source code, and with\n"
206		<< "all binaries) for the full cvc5 copyright, licensing, and (lack of)\n"
207	2602	<< "warranty information.\n";
208	5204	return ss.str();
209		}
210
211	2602	std::string Configuration::about() {
212	5204	std::stringstream ss;
213	2602	ss << "This is cvc5 version " << CVC5_RELEASE_STRING;
214	2602	if (Configuration::isGitBuild()) {
215	2602	ss << " [" << Configuration::getGitId() << "]";
216		}
217	5204	ss << "\ncompiled with " << Configuration::getCompiler()
218	5204	<< "\non " << Configuration::getCompiledDateTime() << "\n\n";
219	2602	ss << Configuration::copyright ();
220	5204	return ss.str();
221		}
222
223	2602	bool Configuration::licenseIsGpl() {
224	2602	return IS_GPL_BUILD;
225		}
226
227	7803	bool Configuration::isBuiltWithGmp() {
228	7803	return IS_GMP_BUILD;
229		}
230
231	7803	bool Configuration::isBuiltWithCln() {
232	7803	return IS_CLN_BUILD;
233		}
234
235	5201	bool Configuration::isBuiltWithGlpk() {
236	5201	return IS_GLPK_BUILD;
237		}
238
239	7803	bool Configuration::isBuiltWithAbc() {
240	7803	return IS_ABC_BUILD;
241		}
242
243	7813	bool Configuration::isBuiltWithCryptominisat() {
244	7813	return IS_CRYPTOMINISAT_BUILD;
245		}
246
247	5201	bool Configuration::isBuiltWithKissat() { return IS_KISSAT_BUILD; }
248
249	5201	bool Configuration::isBuiltWithEditline() { return IS_EDITLINE_BUILD; }
250
251	7803	bool Configuration::isBuiltWithPoly()
252		{
253	7803	return IS_POLY_BUILD;
254		}
255
256		unsigned Configuration::getNumDebugTags() {
257		#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
258		/* -1 because a NULL pointer is inserted as the last value */
259		return (sizeof(Debug_tags) / sizeof(Debug_tags[0])) - 1;
260		#else /* CVC5_DEBUG && CVC5_TRACING */
261		return 0;
262		#endif /* CVC5_DEBUG && CVC5_TRACING */
263		}
264
265		char const* const* Configuration::getDebugTags() {
266		#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
267		return Debug_tags;
268		#else /* CVC5_DEBUG && CVC5_TRACING */
269		static char const* no_tags[] = { NULL };
270		return no_tags;
271		#endif /* CVC5_DEBUG && CVC5_TRACING */
272		}
273
274		int strcmpptr(const char s1, const char s2){
275		return strcmp(s1,s2);
276		}
277
278		bool Configuration::isDebugTag(char const *tag){
279		#if defined(CVC5_DEBUG) && defined(CVC5_TRACING)
280		unsigned ntags = getNumDebugTags();
281		char const* const* tags = getDebugTags();
282		for (unsigned i = 0; i < ntags; ++ i) {
283		if (strcmp(tag, tags[i]) == 0) {
284		return true;
285		}
286		}
287		#endif /* CVC5_DEBUG && CVC5_TRACING */
288		return false;
289		}
290
291		unsigned Configuration::getNumTraceTags() {
292		#if CVC5_TRACING
293		/* -1 because a NULL pointer is inserted as the last value */
294		return sizeof(Trace_tags) / sizeof(Trace_tags[0]) - 1;
295		#else /* CVC5_TRACING */
296		return 0;
297		#endif /* CVC5_TRACING */
298		}
299
300		char const* const* Configuration::getTraceTags() {
301		#if CVC5_TRACING
302		return Trace_tags;
303		#else /* CVC5_TRACING */
304		static char const* no_tags[] = { NULL };
305		return no_tags;
306		#endif /* CVC5_TRACING */
307		}
308
309		bool Configuration::isTraceTag(char const * tag){
310		#if CVC5_TRACING
311		unsigned ntags = getNumTraceTags();
312		char const* const* tags = getTraceTags();
313		for (unsigned i = 0; i < ntags; ++ i) {
314		if (strcmp(tag, tags[i]) == 0) {
315		return true;
316		}
317		}
318		#endif /* CVC5_TRACING */
319		return false;
320		}
321
322	7803	bool Configuration::isGitBuild() {
323	7803	return IS_GIT_BUILD;
324		}
325
326	5201	const char* Configuration::getGitBranchName() {
327	5201	return GIT_BRANCH_NAME;
328		}
329
330	5201	const char* Configuration::getGitCommit() {
331	5201	return GIT_COMMIT;
332		}
333
334	5201	bool Configuration::hasGitModifications() {
335	5201	return GIT_HAS_MODIFICATIONS;
336		}
337
338	2602	std::string Configuration::getGitId() {
339	2602	if(! isGitBuild()) {
340		return "";
341		}
342
343	2602	const char* branchName = getGitBranchName();
344	2602	if(*branchName == '\0') {
345		branchName = "-";
346		}
347
348	5204	stringstream ss;
349	5204	ss << "git " << branchName << " " << string(getGitCommit()).substr(0, 8)
350	5204	<< (::cvc5::Configuration::hasGitModifications() ? " (with modifications)"
351	7806	: "");
352	2602	return ss.str();
353		}
354
355	2602	std::string Configuration::getCompiler() {
356	5204	stringstream ss;
357		#ifdef __GNUC__
358	2602	ss << "GCC";
359		#else /* __GNUC__ */
360		ss << "unknown compiler";
361		#endif /* __GNUC__ */
362		#ifdef __VERSION__
363	2602	ss << " version " << __VERSION__;
364		#else /* __VERSION__ */
365		ss << ", unknown version";
366		#endif /* __VERSION__ */
367	5204	return ss.str();
368		}
369
370	2602	std::string Configuration::getCompiledDateTime() {
371	2602	return __DATE__ " " __TIME__;
372		}
373
374		} // namespace cvc5