tb_values.cc
// INCLUDE THE CLASS DECLARATION

#include "tb_values.h"

// INCLUDE THE CLASSES USED IN THE IMPLEMENTATION

#include <stdlib.h>

//****************************
// CLASS DEFINITION: TB_Values
//****************************

// CONSTRUCTOR

TB_Values::TB_Values()
{}

// DESTRUCTOR

TB_Values::~TB_Values()
{}

// METHOD: random(size, mask)

void
TB_Values::random(unsigned int size, unsigned long mask)
{
    // FOREACH VALUE IN THE READ SEQUENCE

    for (unsigned int icnt=0; icnt < size; ++icnt)

        // SET THE VALUE TO A MASKED RANDOM NUMBER

        d_stimulus.push_back(::rand() & mask);

    // SET THE READ POINTER TO THE START VALUE

    d_read = d_stimulus.begin();
}

// METHOD: sequence(size, mask, constant)

void
TB_Values::sequence(unsigned int size, unsigned long mask, unsigned long constant)
{
    // FOREACH VALUE IN THE READ SEQUENCE

    for (unsigned int icnt=0; icnt < size; ++icnt)

        // SET THE VALUE TO A MASKED COMBINATION OF A CONSTANT AND THE INDEX

        d_stimulus.push_back((constant | 1+icnt) & mask);

    // SET THE READ POINTER TO THE START VALUE

    d_read = d_stimulus.begin();
}

// METHOD: is_equal()

bool
TB_Values::is_equal()
{
    // IF READ AND WRITE SEQUENCES ARE EQUAL RETURN TRUE

    if (equal(d_stimulus.begin(), d_stimulus.end(), d_response.begin())) return true;

    // FOREACH VALUE IN THE READ SEQUENCE

    cerr.setf(ios::hex, ios::basefield);
    for(unsigned int icnt=0; icnt < d_stimulus.size(); ++icnt)

        // IF THE READ SEQUENCE VALUE DIFFERS FROM THE WRITE SEQUENCE VALUE

        if (d_stimulus[icnt] != d_response[icnt])

            // PRINT MISMATCH MESSAGE

            cerr << icnt << ": mismatch expecting 0x" << d_stimulus[icnt]
                 << " received 0x" << d_response[icnt] << endl;

    return false;
}

// METHOD: is_full()

bool
TB_Values::is_full()
{
    return !(d_response.size() < d_stimulus.size());
}

// METHOD: has_value()

bool
TB_Values::has_value()
{
    return d_read != d_stimulus.end();
}

// METHOD: get_value()

unsigned long
TB_Values::get_value()
{
    return *d_read++;
}

// METHOD: put_value(value)

void
TB_Values::put_value(unsigned long value)
{
    d_response.push_back(value);
}

// METHOD: get_read_size()

unsigned long
TB_Values::get_read_size()
{
    // DATA: SET COUNTER TO ZERO

    int count = 0;

    // FOREACH UNREAD VALUE IN THE READ SEQUENCE

    for(vector<unsigned long>::iterator ptr = d_read; ptr != d_stimulus.end(); ++ptr)

        // INCREMENT THE COUNTER

        ++count;

    // RETURN THE COUNTER VALUE

    return count;
}

// METHOD: get_write_size()

unsigned long
TB_Values::get_write_size()
{
    return d_stimulus.size() - d_response.size();
}
© Copyright 2000-2001 Adrian Lewis