static void start_of_sim(const vhpiCbDataT *cb_data)
{
vhpi_printf("start_of_sim");
fail_unless(phys_to_i64(vhpiFS) == 1ll);
fail_unless(phys_to_i64(vhpiPS) == 1000ll);
fail_unless(phys_to_i64(vhpiNS) == 1000000ll);
fail_unless(phys_to_i64(vhpiUS) == 1000000000ll);
fail_unless(phys_to_i64(vhpiMS) == 1000000000000ll);
fail_unless(phys_to_i64(vhpiS) == 1000000000000000ll);
fail_unless(phys_to_i64(vhpiMN) == 1000000000000000ll * 60);
fail_unless(phys_to_i64(vhpiHR) == 1000000000000000ll * 60 * 60);
vhpiPhysT res_limit = vhpi_get_phys(vhpiResolutionLimitP, NULL);
check_error();
fail_unless(phys_to_i64(res_limit) == phys_to_i64(vhpiFS));
vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL);
check_error();
fail_if(root == NULL);
vhpiHandleT handle_x = vhpi_handle_by_name("x", root);
check_error();
fail_if(handle_x == NULL);
vhpi_printf("x handle %p", handle_x);
vhpiPhysT x_val = vhpi_get_phys(vhpiPhysValP, handle_x);
check_error();
fail_unless(phys_to_i64(x_val) == 2);
vhpiHandleT handle_weight_type = vhpi_handle(vhpiType, handle_x);
check_error();
fail_if(handle_weight_type == NULL);
vhpiHandleT handle_weight_cons =
vhpi_handle_by_index(vhpiConstraints, handle_weight_type, 0);
check_error();
fail_if(handle_weight_cons == NULL);
vhpiPhysT weight_left = vhpi_get_phys(vhpiPhysLeftBoundP,
handle_weight_cons);
check_error();
fail_unless(phys_to_i64(weight_left) == -100);
vhpiPhysT weight_right = vhpi_get_phys(vhpiPhysRightBoundP,
handle_weight_cons);
check_error();
fail_unless(phys_to_i64(weight_right) == 4000);
vhpi_release_handle(handle_weight_cons);
vhpi_release_handle(handle_weight_type);
vhpi_release_handle(handle_x);
vhpi_release_handle(root);
}
static void start_of_sim(const vhpiCbDataT *cb_data)
{
vhpi_printf("start of sim callback! user data is '%s'",
(char *)cb_data->user_data);
long cycles;
vhpiTimeT now;
vhpi_get_time(&now, &cycles);
fail_unless(now.low == 0);
fail_unless(now.high == 0);
fail_unless(cycles == 0);
vhpiValueT value = {
.format = vhpiObjTypeVal
};
vhpi_get_value(handle_x, &value);
check_error();
fail_unless(value.format == vhpiIntVal);
fail_unless(value.value.intg == 0);
value.value.intg = 5;
vhpi_put_value(handle_x, &value, vhpiForcePropagate);
check_error();
vhpiTimeT time_5ns = {
.low = 5000000
};
vhpiCbDataT cb_data2 = {
.reason = vhpiCbAfterDelay,
.cb_rtn = after_5ns,
.time = &time_5ns
};
vhpi_register_cb(&cb_data2, 0);
check_error();
}
static void end_of_sim(const vhpiCbDataT *cb_data)
{
vhpi_printf("end of sim callback");
vhpiValueT value = {
.format = vhpiObjTypeVal
};
vhpi_get_value(handle_y, &value);
check_error();
fail_unless(value.format == vhpiIntVal);
fail_unless(value.value.intg == 75);
vhpi_release_handle(handle_x);
vhpi_release_handle(handle_y);
vhpi_release_handle(handle_sos);
}
void cleanValObj( TValObjPtrs* _pValObjs )
{
int j = -1;
// iterate on all structures in table, untill the last element with NULL object handle is reached
while ( _pValObjs[++j].hHdl != NULL )
{
// release memory allocated for handle
vhpi_release_handle( _pValObjs[j].hHdl );
free( _pValObjs[j].szName );
// release memory allocated for vector objects in value structure
switch ( _pValObjs[j].vValue->format )
{
case vhpiEnumVecVal:
delete [] (_pValObjs[j].vValue->value.enumvs);
break;
case vhpiIntVecVal:
delete [] (_pValObjs[j].vValue->value.intgs);
break;
case vhpiRealVecVal:
delete [] (_pValObjs[j].vValue->value.reals);
break;
}
// release memory allocated for value structure
delete (_pValObjs[j].vValue);
// delete pointers
delete ( _pValObjs[j].pBoolVar );
delete ( _pValObjs[j].pIntVar );
delete ( _pValObjs[j].pRealVar );
delete [] ( _pValObjs[j].pBoolVecVar );
delete [] ( _pValObjs[j].pIntVecVar );
delete [] ( _pValObjs[j].pRealVecVar );
}
// delete whole array
delete [] _pValObjs;
}
static void startup()
{
vhpi_printf("hello, world!");
vhpiCbDataT cb_data1 = {
.reason = vhpiCbStartOfSimulation,
.cb_rtn = start_of_sim,
.user_data = (char *)"some user data",
};
handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb);
check_error();
fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable);
vhpiCbDataT cb_data2 = {
.reason = vhpiCbEndOfSimulation,
.cb_rtn = end_of_sim
};
vhpi_register_cb(&cb_data2, 0);
check_error();
vhpi_printf("tool is %s", vhpi_get_str(vhpiNameP, NULL));
vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL);
check_error();
fail_if(root == NULL);
vhpi_printf("root handle %p", root);
handle_x = vhpi_handle_by_name("x", root);
check_error();
fail_if(handle_x == NULL);
vhpi_printf("x handle %p", handle_x);
handle_y = vhpi_handle_by_name("y", root);
check_error();
fail_if(handle_y == NULL);
vhpi_printf("y handle %p", handle_y);
vhpi_release_handle(root);
}
void (*vhpi_startup_routines[])() = {
startup,
NULL
};
VhpiIterator::~VhpiIterator()
{
if (m_iterator)
vhpi_release_handle(m_iterator);
}
// this function adds new object to structure
TValObjPtrs* addValObj( vhpiHandleT _hNewHandle, TValObjPtrs* _pActualPointer, int _nActualSize )
{
TValObjPtrs hNewHandle;
hNewHandle.hHdl = _hNewHandle;
hNewHandle.vValue = getFieldValue( _hNewHandle );
hNewHandle.nIndex = _nActualSize;
hNewHandle.nType = 0;
for ( int i = 0; i < 10; i++ )
{
hNewHandle.enumOnes[i] = -1;
hNewHandle.enumZeros[i] = -1;
}
hNewHandle.enumMin = 2147483647;
hNewHandle.enumMax = 0;
hNewHandle.szName = strdup( (char*)vhpi_get_str( vhpiNameP, _hNewHandle ) );
hNewHandle.pBoolVar = new bool;
hNewHandle.pIntVar = new int;
hNewHandle.pRealVar = new double;
hNewHandle.pUserVars = NULL;
if ( _hNewHandle )
{
if ( ( hNewHandle.vValue->format >= vhpiEnumVecVal ) && ( hNewHandle.vValue->format <= vhpiRealVecVal ) )
{
// if array type ports, when numElems is defined
hNewHandle.pBoolVecVar = new bool [hNewHandle.vValue->numElems];
hNewHandle.pIntVecVar = new int [hNewHandle.vValue->numElems];
hNewHandle.pRealVecVar = new double [hNewHandle.vValue->numElems];
}
else
{
hNewHandle.pBoolVecVar = new bool;
hNewHandle.pIntVecVar = new int;
hNewHandle.pRealVecVar = new double;
}
// detect binary logic enum types to enable numerical conversions
if ( ( hNewHandle.vValue->format == vhpiEnumVal ) || ( hNewHandle.vValue->format == vhpiEnumVecVal ) )
{
vhpiHandleT hLiteralIt = NULL;
vhpiHandleT hLiteralHdl = NULL;
vhpiHandleT hTypeHdl = NULL;
int nTypeIndex = 0;
int nOnesIndex = 0;
int nZerosIndex = 0;
// get handle to object type
hTypeHdl = vhpi_handle( vhpiBaseType, _hNewHandle );
// iterate on all literals of scalar type
if (( hLiteralIt = vhpi_iterator( vhpiEnumLiterals, hTypeHdl ) ));
// iterate on all literals of array's element type
else (( hLiteralIt = vhpi_iterator( vhpiEnumLiterals, vhpi_handle( vhpiElemSubtype, hTypeHdl ) ) ));
if ( hLiteralIt )
while (( hLiteralHdl = vhpi_scan( hLiteralIt ) ))
{
// get literal string value
char* szStrVal;
szStrVal = strdup( (char*)vhpi_get_str( vhpiStrValP, hLiteralHdl ) );
// get its position (index) in enum type
nTypeIndex = vhpi_get( vhpiPositionP, hLiteralHdl );
// set the limits of indexes in enum type
if ( nTypeIndex > hNewHandle.enumMax )
hNewHandle.enumMax = nTypeIndex;
if ( nTypeIndex < hNewHandle.enumMin )
hNewHandle.enumMin = nTypeIndex;
// check if literal string value belongs to binary logic values set
if ( ( strcmp( szStrVal, "1" ) == 0 ) || ( strcmp( szStrVal, "H" ) == 0 ) )
// store indexes of literals treated as one in numeric calculations
hNewHandle.enumOnes[nOnesIndex++] = nTypeIndex;
else if ( ( strcmp( szStrVal, "0" ) == 0 ) || ( strcmp( szStrVal, "L" ) == 0 ) )
// store indexes of literals treated as zero in numeric calculations
hNewHandle.enumZeros[nZerosIndex++] = nTypeIndex;
free( szStrVal );
}
else
vhpi_printf( "addVAlObj(): No enum literals found.\n" );
// if type contains one and zero literals
if ( ( nZerosIndex != 0 ) && ( nOnesIndex != 0 ) )
hNewHandle.nType = 1;
// release handles
vhpi_release_handle( hTypeHdl );
vhpi_release_handle( hLiteralHdl );
}
}
// reallocate array appended with new structure
TValObjPtrs* hTempHandle;
int index;
// allocate memory for copy of actual handles array
hTempHandle = new TValObjPtrs [_nActualSize+1];
// copy array contents
for ( index = 0; index < _nActualSize; index++ )
{
hTempHandle[index] = _pActualPointer[index];
}
// append array with new object handle
hTempHandle[index++] = hNewHandle;
// remove actual array from memory
delete [] _pActualPointer ;
// allocate memory for new actual array
_pActualPointer = new TValObjPtrs [_nActualSize+1];
// copy array contents from temp array
for ( index = 0; index < _nActualSize + 1; index++ )
{
_pActualPointer[index] = hTempHandle[index];
}
// remove temp array
delete [] hTempHandle;
return _pActualPointer;
}
static void test_bin_str(void)
{
vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL);
check_error();
vhpiHandleT hb = vhpi_handle_by_name("b", root);
check_error();
vhpiHandleT hv = vhpi_handle_by_name("v", root);
check_error();
char b_str[2] = { 0xff, 0xff };
vhpiValueT b_value = {
.format = vhpiBinStrVal,
.bufSize = sizeof(b_str),
.value.str = (vhpiCharT *)b_str
};
vhpi_get_value(hb, &b_value);
check_error();
vhpi_printf("b bit string '%s' %x", b_str);
fail_unless(strcmp(b_str, "0") == 0);
vhpiValueT v_value = {
.format = vhpiBinStrVal,
.bufSize = 0,
.value.str = NULL
};
const int need = vhpi_get_value(hv, &v_value);
check_error();
vhpi_printf("need %d bytes for v string", need);
v_value.value.str = malloc(need);
v_value.bufSize = need;
fail_if(v_value.value.str == NULL);
fail_unless(vhpi_get_value(hv, &v_value) == 0);
check_error();
vhpi_printf("v bit string '%s'", v_value.value.str);
fail_unless(strcmp((char *)v_value.value.str, "0011") == 0);
free(v_value.value.str);
vhpi_release_handle(root);
vhpi_release_handle(hb);
vhpi_release_handle(hv);
}
static void y_value_change(const vhpiCbDataT *cb_data)
{
vhpiValueT value = {
.format = vhpiObjTypeVal
};
vhpi_get_value(handle_y, &value);
check_error();
fail_unless(value.format == vhpiIntVal);
vhpi_printf("y value changed to %d", value.value.intg);
if (value.value.intg == 75) {
test_bin_str();
vhpi_control(vhpiFinish);
check_error();
}
else {
value.value.intg++;
vhpi_put_value(handle_x, &value, vhpiForcePropagate);
check_error();
}
}
static void after_5ns(const vhpiCbDataT *cb_data)
{
vhpi_printf("after_5ns callback!");
long cycles;
vhpiTimeT now;
vhpi_get_time(&now, &cycles);
fail_unless(now.low == 5000000);
fail_unless(now.high == 0);
fail_unless(cycles == 0);
vhpiValueT value = {
.format = vhpiObjTypeVal
};
vhpi_get_value(handle_y, &value);
check_error();
fail_unless(value.format == vhpiIntVal);
fail_unless(value.value.intg == 6);
value.value.intg = 70;
vhpi_put_value(handle_x, &value, vhpiForcePropagate);
check_error();
vhpiCbDataT cb_data2 = {
.reason = vhpiCbValueChange,
.cb_rtn = y_value_change,
.obj = handle_y
};
vhpi_register_cb(&cb_data2, 0);
check_error();
}
