const char* FliLogicObjHdl::get_signal_value_binstr(void)
{
switch (m_fli_type) {
case MTI_TYPE_ENUM:
if (m_is_var) {
m_val_buff[0] = m_value_enum[mti_GetVarValue(get_handle<mtiVariableIdT>())][1];
} else {
m_val_buff[0] = m_value_enum[mti_GetSignalValue(get_handle<mtiSignalIdT>())][1];
}
break;
case MTI_TYPE_ARRAY: {
if (m_is_var) {
mti_GetArrayVarValue(get_handle<mtiVariableIdT>(), m_mti_buff);
} else {
mti_GetArraySignalValue(get_handle<mtiSignalIdT>(), m_mti_buff);
}
for (int i = 0; i < m_num_elems; i++ ) {
m_val_buff[i] = m_value_enum[(int)m_mti_buff[i]][1];
}
}
break;
default:
LOG_CRITICAL("Object type is not 'logic' for %s (%d)", m_name.c_str(), m_fli_type);
return NULL;
}
LOG_DEBUG("Retrieved \"%s\" for value object %s", m_val_buff, m_name.c_str());
return m_val_buff;
}
const char* FliStringObjHdl::get_signal_value_str(void)
{
if (m_is_var) {
mti_GetArrayVarValue(get_handle<mtiVariableIdT>(), m_mti_buff);
} else {
mti_GetArraySignalValue(get_handle<mtiSignalIdT>(), m_mti_buff);
}
strncpy(m_val_buff, m_mti_buff, m_num_elems);
LOG_DEBUG("Retrieved \"%s\" for value object %s", m_val_buff, m_name.c_str());
return m_val_buff;
}
const char* FliSignalObjHdl::get_signal_value_binstr(void)
{
switch (m_fli_type) {
case MTI_TYPE_ENUM:
m_val_buff[0] = value_enum[mti_GetSignalValue(m_fli_hdl)];
break;
case MTI_TYPE_SCALAR:
case MTI_TYPE_PHYSICAL: {
std::bitset<32> value((unsigned long)mti_GetSignalValue(m_fli_hdl));
std::string bin_str = value.to_string<char,std::string::traits_type, std::string::allocator_type>();
snprintf(m_val_buff, m_val_len+1, "%s", bin_str.c_str());
}
break;
case MTI_TYPE_ARRAY: {
mti_GetArraySignalValue(m_fli_hdl, m_mti_buff);
if (m_val_len <= 256) {
char *iter = (char*)m_mti_buff;
for (int i = 0; i < m_val_len; i++ ) {
m_val_buff[i] = value_enum[(int)iter[i]];
}
} else {
for (int i = 0; i < m_val_len; i++ ) {
m_val_buff[i] = value_enum[m_mti_buff[i]];
}
}
}
break;
default:
LOG_CRITICAL("Signal %s type %d not currently supported",
m_name.c_str(), m_fli_type);
break;
}
LOG_DEBUG("Retrieved \"%s\" for signal %s", m_val_buff, m_name.c_str());
return m_val_buff;
}
/*
* This procedure is called by the simulator as a result of an
* mti_ScheduleWakeup() call. Its purpose is to process all drive/test
* data specified for the current timestep. It schedules drivers for
* drive points by calling mti_ScheduleDriver(). For test points, it
* reads the port values by calling either mti_GetSignalValue() or
* mti_GetArraySignalValue(). It then compares the current values with the
* expected values and prints an error message if they don't match.
*/
static void test_value_proc( void * param )
{
inst_rec_ptr ip = (inst_rec_ptr)param;
char actual_val[MAX_PORT_WIDTH];
char buf[100];
char expected_val[MAX_PORT_WIDTH];
char *sig_array_val;
int portnum, i, width, is_array;
long now;
long sigval;
testpoint *cur_testpoint;
now = mti_Now();
for ( cur_testpoint=testpoints; cur_testpoint;
cur_testpoint=cur_testpoint->nxt) {
portnum = cur_testpoint->portnum;
width = tester_ports[portnum].width;
is_array = tester_ports[portnum].is_array_type;
if ( cur_testpoint->type == DRIVE ) {
if ( ! is_array ) {
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: drive signal %s with value %c\n",
now, tester_ports[portnum].name,
convert_enum_to_mvl9_char(*cur_testpoint->test_val));
mti_PrintMessage(buf);
}
mti_ScheduleDriver( ip->drivers[portnum],
(mtiLongT) *cur_testpoint->test_val,
0, MTI_INERTIAL );
} else {
char tmpstring[MAX_PORT_WIDTH];
convert_enums_to_mvl9_string( cur_testpoint->test_val,
tmpstring, width );
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: drive signal array %s with value %s\n",
now, tester_ports[portnum].name, tmpstring);
mti_PrintMessage(buf);
}
mti_ScheduleDriver( ip->drivers[portnum],
(mtiLongT)(cur_testpoint->test_val),
0, MTI_INERTIAL );
}
} else {
if ( ! is_array ) {
char exp, act;
sigval = mti_GetSignalValue(ip->ports[portnum]);
exp = convert_enum_to_mvl9_char(*cur_testpoint->test_val);
act = convert_enum_to_mvl9_char(sigval);
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: test signal %s for value %c\n",
now, tester_ports[portnum].name, exp);
mti_PrintMessage(buf);
}
if ( sigval != (long) *cur_testpoint->test_val ) {
sprintf( buf,
"Miscompare at time %ld, signal %s. "
"Expected \'%c\', Actual \'%c\'\n",
now, tester_ports[portnum].name, exp, act);
mti_PrintMessage(buf);
}
} else {
sig_array_val = mti_GetArraySignalValue(ip->ports[portnum],
NULL);
convert_enums_to_mvl9_string(cur_testpoint->test_val,
expected_val, width);
convert_enums_to_mvl9_string(sig_array_val, actual_val, width);
if ( ip->verbose ) {
sprintf(buf,"TIME %ld: test signal %s for value %s\n",
now, tester_ports[portnum].name, expected_val);
mti_PrintMessage(buf);
}
for ( i = 0; i < width; i++ ) {
if ( sig_array_val[i] != cur_testpoint->test_val[i] ) {
sprintf( buf,
"Miscompare at time %ld, signal %s. "
"Expected \"%s\", Actual \"%s\"\n",
now, tester_ports[portnum].name,
expected_val, actual_val);
mti_PrintMessage( buf );
break;
}
}
}
}
}
delete_testpoints();
read_next_statement(ip);
}
