CmdMem Class Reference

#include <TestOsal.hh>

Inheritance diagram for CmdMem:

Collaboration diagram for CmdMem:

Public Member Functions
	CmdMem ()
	CmdMem (const CmdMem &cmd)
virtual	~CmdMem ()
virtual bool	execute (const std::vector< DataObject > &arguments)
virtual std::string	helpText () const
Public Member Functions inherited from CustomCommand
	CustomCommand (std::string name)
	CustomCommand (const CustomCommand &cmd)
virtual	~CustomCommand ()
std::string	name () const
void	setContext (InterpreterContext *context)
InterpreterContext *	context () const
void	setInterpreter (ScriptInterpreter *si)
ScriptInterpreter *	interpreter () const
bool	checkArgumentCount (int argumentCount, int minimum, int maximum)
bool	checkIntegerArgument (const DataObject &argument)
bool	checkPositiveIntegerArgument (const DataObject &argument)
bool	checkUnsignedIntegerArgument (const DataObject &argument)
bool	checkDoubleArgument (const DataObject &argument)

Static Public Attributes
static const std::string	MEM_BYTE = "byte"
	Name for byte memory access. More...
static const std::string	MEM_HALF_WORD = "halfword"
	Name for half word memory access. More...
static const std::string	MEM_WORD = "word"
	Name for word memory access. More...
static const std::string	MEM_DOUBLE_WORD = "double"
	Name for double word memory access. More...

Detailed Description

Command for viewing memory contents.

This implementation expects that MAU is 1 byte.

Definition at line 168 of file TestOsal.hh.

Constructor & Destructor Documentation

CmdMem() [1/2]

CmdMem::CmdMem

(

)

Constructor.

Definition at line 710 of file TestOsal.cc.

               : CustomCommand("mem") {
}

CmdMem() [2/2]

CmdMem::CmdMem ( const CmdMem &  cmd )

explicit

Copy constructor.

Parameters

cmd	Command to be copied.

Definition at line 718 of file TestOsal.cc.

                                : CustomCommand(cmd) {
}

~CmdMem()

CmdMem::~CmdMem ( )

virtual

Destructor.

Definition at line 724 of file TestOsal.cc.

                {
}

Member Function Documentation

execute()

bool CmdMem::execute ( const std::vector< DataObject > &  arguments )

virtual

Executes the command.

Parameters

arguments

Arguments for the command.

Returns

True if execution is successful, false otherwise.

Exceptions

NumberFormatException

If DataObject conversion fails.

Implements CustomCommand.

Definition at line 735 of file TestOsal.cc.

                                                      {
    ScriptInterpreter* scriptInterp = interpreter();
    OsalInterpreter* interp = dynamic_cast<OsalInterpreter*>(scriptInterp);
    assert(interp != NULL);
 
    DataObject* result = new DataObject();
 
    if (arguments.size() != 3) {
        result->setString("wrong number of arguments");
        interp->setResult(result);
        return false;
    }
 
    string size = arguments[1].stringValue();
 
    if (size != MEM_BYTE &&
        size != MEM_HALF_WORD &&
        size != MEM_WORD &&
        size != MEM_DOUBLE_WORD) {
 
        result->setString("invalid memory size: " + size);
        interp->setResult(result);
        return false;
    }
 
    TesterContext& context =
        *(dynamic_cast<TesterContext*>(&interp->context()));
 
    Memory& memory = context.operationContext().memory();
 
    Word address = 0;
    string addressString = arguments[2].stringValue();
 
    try {
        address = Conversion::toInt(addressString);
    } catch(const NumberFormatException& n) {
        result->setString("illegal address: " + addressString);
        interp->setResult(result);
        return false;
    }
 
    SimValue resultValue(64);
 
    try {
        if (context.outputFormat() == CmdOutput::OUTPUT_FORMAT_LONG_UNSIGNED ||
            context.outputFormat() == CmdOutput::OUTPUT_FORMAT_LONG_SIGNED) {
            resultValue.setBitWidth(64);
        }
        if (size == MEM_BYTE) {
            resultValue.setBitWidth(8);
            ULongWord resultInt = 0;
            memory.read(address, 1, resultInt);
            resultValue = resultInt;
        } else if (size == MEM_HALF_WORD) {
            resultValue.setBitWidth(16);
            ULongWord resultInt = 0;
            memory.read(address, 2, resultInt);
            resultValue = resultInt;
        } else if (size == MEM_WORD) {
            resultValue.setBitWidth(32);
            ULongWord resultInt = 0;
            memory.read(address, 4, resultInt);
            resultValue = resultInt;
        } else if (size == MEM_DOUBLE_WORD) {
            resultValue.setBitWidth(64);
 
            DoubleWord result = 0.0;
            // TODO: when to read in LE?
            memory.readBE(address, result);
            resultValue = result;
        }
    } catch (const OutOfRange& o) {
        string addressString = Conversion::toString(address);
        result->setString("address " + addressString + " out of memory bounds");
        interp->setResult(result);
        return false;
    }
    string output = context.toOutputFormat(&resultValue);
    result->setString(output);
    interp->setResult(result);
    return true;
}

References assert, CustomCommand::context(), SimpleScriptInterpreter::context(), CustomCommand::interpreter(), MEM_BYTE, MEM_DOUBLE_WORD, MEM_HALF_WORD, MEM_WORD, CmdOutput::OUTPUT_FORMAT_LONG_SIGNED, CmdOutput::OUTPUT_FORMAT_LONG_UNSIGNED, Memory::read(), Memory::readBE(), SimValue::setBitWidth(), ScriptInterpreter::setResult(), DataObject::setString(), Conversion::toInt(), and Conversion::toString().

Here is the call graph for this function:

helpText()

string CmdMem::helpText ( ) const

virtual

Returns the help text of the command.

Returns

The help text.

Implements CustomCommand.

Definition at line 824 of file TestOsal.cc.

                       {
    return
        "Prints the contents of the memory.\n"
        "!mem <size> <address>\n"
        "size is one of the following:\n{" +
        MEM_BYTE + "|" + MEM_HALF_WORD + "|" + MEM_WORD + "|" +
        MEM_DOUBLE_WORD + "}";
}

References MEM_BYTE, MEM_DOUBLE_WORD, MEM_HALF_WORD, and MEM_WORD.

Member Data Documentation

MEM_BYTE

const string CmdMem::MEM_BYTE = "byte"

static

Name for byte memory access.

Definition at line 172 of file TestOsal.hh.

Referenced by execute(), and helpText().

MEM_DOUBLE_WORD

const string CmdMem::MEM_DOUBLE_WORD = "double"

static

Name for double word memory access.

Definition at line 178 of file TestOsal.hh.

Referenced by execute(), and helpText().

MEM_HALF_WORD

const string CmdMem::MEM_HALF_WORD = "halfword"

static

Name for half word memory access.

Definition at line 174 of file TestOsal.hh.

Referenced by execute(), and helpText().

MEM_WORD

const string CmdMem::MEM_WORD = "word"

static

Name for word memory access.

Definition at line 176 of file TestOsal.hh.

Referenced by execute(), and helpText().

---

The documentation for this class was generated from the following files:

• TestOsal.hh
• TestOsal.cc