#include "systemc/ext/dt/bit/sc_bit.hh"
#include "systemc/ext/dt/bit/sc_logic.hh"
+#include "systemc/ext/utils/messages.hh"
#include "systemc/ext/utils/sc_report_handler.hh"
namespace sc_dt
static bool warn_sc_bit_deprecated = true;
if (warn_sc_bit_deprecated) {
warn_sc_bit_deprecated = false;
- SC_REPORT_INFO("(I804) /IEEE_Std_1666/deprecated",
+ SC_REPORT_INFO(sc_core::SC_ID_IEEE_1666_DEPRECATION_,
"sc_bit is deprecated, use bool instead");
}
}
#include <sstream>
#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/utils/messages.hh"
namespace sc_dt
{
ss << msg;
if (val != 0)
ss << val;
- SC_REPORT_ERROR("(E5) out of bounds", ss.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, ss.str().c_str());
}
// ----------------------------------------------------------------------------
#include <cstdlib>
#include "systemc/ext/dt/fx/sc_fxval.hh"
+#include "systemc/ext/utils/messages.hh"
namespace sc_dt
{
step = 4;
break;
default:
- SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep");
+ SC_REPORT_FATAL(sc_core::SC_ID_ASSERTION_FAILED_,
+ "unexpected sc_numrep");
sc_core::sc_abort();
}
#include "systemc/ext/dt/fx/scfx_rep.hh"
#include "systemc/ext/dt/fx/scfx_utils.hh"
#include "systemc/ext/utils/endian.hh"
+#include "systemc/ext/utils/messages.hh"
namespace sc_dt
{
step = 4;
break;
default:
- SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep");
+ SC_REPORT_FATAL(sc_core::SC_ID_ASSERTION_FAILED_,
+ "unexpected sc_numrep");
sc_core::sc_abort();
}
#include "systemc/ext/dt/int/sc_uint_base.hh"
#include "systemc/ext/dt/int/sc_unsigned.hh"
#include "systemc/ext/dt/misc/sc_concatref.hh"
+#include "systemc/ext/utils/messages.hh"
// explicit template instantiations
namespace sc_core
std::stringstream msg;
msg << "sc_int_concref<T1,T2> initialization: length = " << length <<
"violates 1 <= length <= " << SC_INTWIDTH;
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
std::stringstream msg;
msg << "sc_int[_base] initialization: length = " << m_len <<
" violates 1 <= length <= " << SC_INTWIDTH;
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
std::stringstream msg;
msg << "sc_int[_base] bit selection: index = " << i <<
" violates 0 <= index <= " << (m_len - 1);
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
msg << "sc_int[_base] part selection: " <<
"left = " << l << ", right = " << r << " violates " <<
(m_len-1) << " >= left >= right >= 0";
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
if (m_val < -limit || m_val >= limit) {
std::stringstream msg;
msg << "sc_int[_base]: value does not fit into a length of " << m_len;
- SC_REPORT_WARNING("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_WARNING(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
}
}
std::stringstream msg;
msg << "sc_bigint bit selection: index = " << i << " violates "
"0 <= index <= " << (nbits - 1);
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
l << ", right = " << r << " \n"
" violates either (" << (nbits-1) << " >= left >= 0) or "
"(" << (nbits-1) << " >= right >= 0)";
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
std::stringstream msg;
msg << "sc_uint_concref<T1,T2> initialization: length = " << length <<
"violates 1 <= length <= " << SC_INTWIDTH;
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
std::stringstream msg;
msg << "sc_uint[_base] initialization: length = " << m_len <<
" violates 1 <= length <= " << SC_INTWIDTH;
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here}
}
std::stringstream msg;
msg << "sc_uint[_base] bit selection: index = " << i <<
" violates 0 <= index <= " << (m_len - 1);
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
msg << "sc_uint[_base] part selection: " <<
"left = " << l << ", right = " << r << " violates " <<
(m_len - 1) << " >= left >= right >= 0";
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
if (m_val > limit) {
std::stringstream msg;
msg << "sc_uint[_base]: value does not fit into a length of " << m_len;
- SC_REPORT_WARNING("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_WARNING(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
}
}
#include "systemc/ext/dt/int/sc_uint_base.hh"
#include "systemc/ext/dt/int/sc_unsigned.hh"
#include "systemc/ext/dt/misc/sc_concatref.hh"
+#include "systemc/ext/utils/messages.hh"
// explicit template instantiations
namespace sc_core
std::stringstream msg;
msg << "sc_biguint bit selection: index = " << i << " violates "
"0 <= index <= " << (nbits-2);
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
l << ", right = " << r << " \n"
" violates either (" << (nbits - 2) << " >= left >= 0) or "
"(" << (nbits-2) << " >= right >= 0)";
- SC_REPORT_ERROR("(E5) out of bounds", msg.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
sc_core::sc_abort(); // can't recover from here
}
#include <iostream>
+#include "../../utils/messages.hh"
#include "sc_proxy.hh"
namespace sc_dt
if (n == 0) {
return m_obj.get_bit(m_index);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
return Log_0;
}
}
if (n == 0) {
return (get_bit(n) & SC_DIGIT_ONE);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
return 0;
}
}
if (n == 0) {
return ((get_bit(n) & SC_DIGIT_TWO) >> 1);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
return 0;
}
}
if (n == 0) {
this->m_obj.set_bit(this->m_index, value);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
}
temp = (temp & ~(1 << bi)) | ((w & 1) << bi);
this->m_obj.set_word(wi, temp);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
}
temp = (temp & ~(1 << bi)) | ((w & 1) << bi);
this->m_obj.set_cword(wi, temp);
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
}
{
int len = m_obj.length();
if (m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len) {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
sc_core::sc_abort(); // can't recover from here
}
if (reversed()) {
} else if (n < r_len + m_left.length()) {
return value_type(m_left.get_bit(n - r_len));
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
return Log_0;
}
}
} else if (n < r_len + m_left.length()) {
m_left.set_bit(n - r_len, typename X::value_type(v));
} else {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
}
sc_concref_r<X, Y>::get_word(int i) const
{
if (i < 0 || i >= size()) {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
// 0 <= i < size()
Y &r = m_right;
sc_concref_r<X, Y>::set_word(int i, sc_digit w)
{
if (i < 0 || i >= size()) {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
// 0 <= i < size()
Y &r = m_right;
sc_concref_r<X, Y>::get_cword(int i) const
{
if (i < 0 || i >= size()) {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
// 0 <= i < size()
Y &r = m_right;
sc_concref_r<X, Y>::set_cword(int i, sc_digit w)
{
if (i < 0 || i >= size()) {
- SC_REPORT_ERROR("(E5) out of bounds", 0);
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, 0);
}
// 0 <= i < size()
Y &r = m_right;
#ifndef __SYSTEMC_EXT_DT_FX_SC_FXDEFS_HH__
#define __SYSTEMC_EXT_DT_FX_SC_FXDEFS_HH__
+#include "../../utils/messages.hh"
#include "../../utils/sc_report_handler.hh"
#include "../int/sc_nbutils.hh"
#ifdef DEBUG_SYSTEMC
# define SC_ASSERT_(cnd, msg) \
- SC_ERROR_IF_IMPL_(!(cnd), "internal error", msg)
+ SC_ERROR_IF_IMPL_(!(cnd), sc_core::SC_ID_INTERNAL_ERROR_, msg)
#else
# define SC_ASSERT_(cnd, msg) (void(0))
#endif
using sc_core::sc_copyright;
using sc_core::sc_version;
+using sc_core::SC_ID_UNKNOWN_ERROR_;
+using sc_core::SC_ID_WITHOUT_MESSAGE_;
+using sc_core::SC_ID_NOT_IMPLEMENTED_;
+using sc_core::SC_ID_INTERNAL_ERROR_;
+using sc_core::SC_ID_ASSERTION_FAILED_;
+using sc_core::SC_ID_OUT_OF_BOUNDS_;
+using sc_core::SC_ID_ABORT_;
+
+using sc_core::SC_ID_REGISTER_ID_FAILED_;
+using sc_core::SC_ID_STRING_TOO_LONG_;
+using sc_core::SC_ID_FRONT_ON_EMPTY_LIST_;
+using sc_core::SC_ID_BACK_ON_EMPTY_LIST_;
+using sc_core::SC_ID_IEEE_1666_DEPRECATION_;
+using sc_core::SC_ID_VECTOR_INIT_CALLED_TWICE_;
+using sc_core::SC_ID_VECTOR_BIND_EMPTY_;
+using sc_core::SC_ID_VECTOR_NONOBJECT_ELEMENTS_;
+
#endif //__SYSTEMC_EXT_UTILS__USING_HH__
#define __SYSTEMC_EXT_UTIL__UTIL_HH__
#include "functions.hh"
+#include "messages.hh"
#include "sc_exception.hh"
#include "sc_report.hh"
#include "sc_report_handler.hh"
--- /dev/null
+/*
+ * Copyright 2018 Google, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Gabe Black
+ */
+
+#ifndef __SYSTEMC_EXT_UTILS_MESSAGES_HH__
+#define __SYSTEMC_EXT_UTILS_MESSAGES_HH__
+
+namespace sc_core
+{
+
+extern const char SC_ID_UNKNOWN_ERROR_[];
+extern const char SC_ID_WITHOUT_MESSAGE_[];
+extern const char SC_ID_NOT_IMPLEMENTED_[];
+extern const char SC_ID_INTERNAL_ERROR_[];
+extern const char SC_ID_ASSERTION_FAILED_[];
+extern const char SC_ID_OUT_OF_BOUNDS_[];
+extern const char SC_ID_ABORT_[];
+
+extern const char SC_ID_REGISTER_ID_FAILED_[];
+extern const char SC_ID_STRING_TOO_LONG_[];
+extern const char SC_ID_FRONT_ON_EMPTY_LIST_[];
+extern const char SC_ID_BACK_ON_EMPTY_LIST_[];
+extern const char SC_ID_IEEE_1666_DEPRECATION_[];
+extern const char SC_ID_VECTOR_INIT_CALLED_TWICE_[];
+extern const char SC_ID_VECTOR_BIND_EMPTY_[];
+extern const char SC_ID_VECTOR_NONOBJECT_ELEMENTS_[];
+
+} // namespace sc_core
+
+#endif // __SYSTEMC_EXT_UTILS_MESSAGES_HH__
#include <string>
+#include "messages.hh"
#include "sc_report.hh" // for sc_severity
namespace sc_core
::sc_core::SC_FATAL, msg_type, msg, __FILE__, __LINE__)
#define sc_assert(expr) \
- ((void)((expr) ? 0 : (SC_REPORT_FATAL("assertion failed", #expr), 0)))
+ ((void)((expr) ? 0 : (SC_REPORT_FATAL( \
+ ::sc_core::SC_ID_ASSERTION_FAILED_, #expr), 0)))
void sc_interrupt_here(const char *msg_type, sc_severity);
void sc_stop_here(const char *msg_type, sc_severity);
#include "../core/sc_module.hh"
#include "../core/sc_object.hh"
+#include "messages.hh"
namespace sc_gem5
{
sc_object *implicitCast(sc_object *p) const { return p; }
sc_object *implicitCast(...) const
{
- SC_REPORT_ERROR(
- "(E808) sc_vector::get_elements called for element type "
- "not derived from sc_object", name());
+ SC_REPORT_ERROR(SC_ID_VECTOR_NONOBJECT_ELEMENTS_, name());
return nullptr;
}
virtual sc_object *objectCast(void *) const = 0;
if env['USE_SYSTEMC']:
Source('functions.cc')
+ Source('messages.cc')
Source('report.cc')
Source('sc_report.cc')
Source('sc_report_handler.cc')
--- /dev/null
+/*
+ * Copyright 2018 Google, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Gabe Black
+ */
+
+#include "systemc/ext/utils/messages.hh"
+#include "systemc/utils/report.hh"
+
+namespace sc_core
+{
+
+const char SC_ID_REGISTER_ID_FAILED_[] = "register_id failed";
+const char SC_ID_UNKNOWN_ERROR_[] = "unknown error";
+const char SC_ID_WITHOUT_MESSAGE_[] = "";
+const char SC_ID_NOT_IMPLEMENTED_[] = "not implemented";
+const char SC_ID_INTERNAL_ERROR_[] = "internal error";
+const char SC_ID_ASSERTION_FAILED_[] = "assertion failed";
+const char SC_ID_OUT_OF_BOUNDS_[] = "out of bounds";
+const char SC_ID_ABORT_[] = "simulation aborted";
+
+const char SC_ID_STRING_TOO_LONG_[] = "string is too long";
+const char SC_ID_FRONT_ON_EMPTY_LIST_[] =
+ "attempt to take front() on an empty list";
+const char SC_ID_BACK_ON_EMPTY_LIST_[] =
+ "attempt to take back() on an empty list";
+const char SC_ID_IEEE_1666_DEPRECATION_[] =
+ "/IEEE_Std_1666/deprecated";
+const char SC_ID_VECTOR_INIT_CALLED_TWICE_[] =
+ "sc_vector::init has already been called";
+const char SC_ID_VECTOR_BIND_EMPTY_[] =
+ "sc_vector::bind called with empty range";
+const char SC_ID_VECTOR_NONOBJECT_ELEMENTS_[] =
+ "sc_vector::get_elements called for element type "
+ "not derived from sc_object";
+
+namespace
+{
+
+sc_gem5::DefaultReportMessages predefinedMessages{
+ {800, SC_ID_REGISTER_ID_FAILED_},
+ {0, SC_ID_UNKNOWN_ERROR_},
+ {1, SC_ID_WITHOUT_MESSAGE_},
+ {2, SC_ID_NOT_IMPLEMENTED_},
+ {3, SC_ID_INTERNAL_ERROR_},
+ {4, SC_ID_ASSERTION_FAILED_},
+ {5, SC_ID_OUT_OF_BOUNDS_},
+
+ {99, SC_ID_ABORT_},
+
+ {801, SC_ID_STRING_TOO_LONG_},
+ {802, SC_ID_FRONT_ON_EMPTY_LIST_},
+ {803, SC_ID_BACK_ON_EMPTY_LIST_},
+ {804, SC_ID_IEEE_1666_DEPRECATION_},
+ {805, SC_ID_VECTOR_INIT_CALLED_TWICE_},
+ {807, SC_ID_VECTOR_BIND_EMPTY_},
+ {808, SC_ID_VECTOR_NONOBJECT_ELEMENTS_}
+};
+
+} // anonymous namespace
+
+} // namespace sc_core
#include <cstring>
#include "base/logging.hh"
+#include "systemc/ext/utils/messages.hh"
#include "systemc/ext/utils/sc_report.hh"
#include "systemc/ext/utils/sc_report_handler.hh"
#include "systemc/utils/report.hh"
sc_report::register_id(int id, const char *msg)
{
if (id < 0) {
- SC_REPORT_ERROR("(E800) register_id failed", "invalid report id");
+ SC_REPORT_ERROR(SC_ID_REGISTER_ID_FAILED_, "invalid report id");
return;
}
if (!msg) {
- SC_REPORT_ERROR("(E800) register_id failed", "invalid report message");
+ SC_REPORT_ERROR(SC_ID_REGISTER_ID_FAILED_, "invalid report message");
return;
}
auto p = sc_gem5::reportIdToMsgMap.insert(
std::pair<int, std::string>(id, msg));
if (!p.second) {
- SC_REPORT_ERROR("(E800) register_id failed",
- "report id already exists");
+ SC_REPORT_ERROR(SC_ID_REGISTER_ID_FAILED_, "report id already exists");
} else {
sc_gem5::reportMsgInfoMap[msg].id = id;
}
const char *file, int line)
{
std::string &msg_type = sc_gem5::reportIdToMsgMap[id];
- if (msg_type == "")
- msg_type = "unknown id";
if (sc_gem5::reportWarningsAsErrors && severity == SC_WARNING)
severity = SC_ERROR;
#include "base/cprintf.hh"
#include "systemc/core/object.hh"
+#include "systemc/ext/utils/messages.hh"
#include "systemc/ext/utils/sc_report_handler.hh"
#include "systemc/ext/utils/sc_vector.hh"
if (index >= size()) {
std::ostringstream ss;
ccprintf(ss, "%s[%d] >= size() = %d", name(), index, size());
- SC_REPORT_ERROR("(E5) out of bounds", ss.str().c_str());
+ SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, ss.str().c_str());
sc_abort();
}
}
else
ss << "empty destination range given";
- SC_REPORT_WARNING("(W807) sc_vector::bind called with empty range",
- ss.str().c_str());
+ SC_REPORT_WARNING(SC_ID_VECTOR_BIND_EMPTY_, ss.str().c_str());
}
} // namespace sc_core
projects / gem5.git / commitdiff