MemDumpCommand Class Reference

#include <MemDumpCommand.hh>

Inheritance diagram for MemDumpCommand:

Collaboration diagram for MemDumpCommand:

Public Member Functions
	MemDumpCommand ()
virtual	~MemDumpCommand ()
virtual bool	execute (const std::vector< DataObject > &arguments)
virtual std::string	helpText () const
Public Member Functions inherited from SimControlLanguageCommand
	SimControlLanguageCommand (const std::string &name)
virtual	~SimControlLanguageCommand ()
SimulatorFrontend &	simulatorFrontend ()
const SimulatorFrontend &	simulatorFrontendConst ()
virtual void	printNextInstruction ()
virtual void	printStopInformation ()
virtual void	printStopReasons ()
virtual bool	printBreakpointInfo (unsigned int breakpointHandle)
virtual void	printSimulationTime ()
virtual std::ostream &	outputStream ()
bool	checkSimulationInitialized ()
bool	checkSimulationNotAlreadyRunning ()
bool	checkSimulationStopped ()
bool	checkSimulationEnded ()
bool	checkProgramLoaded ()
bool	checkMachineLoaded ()
InstructionAddress	parseInstructionAddressExpression (const std::string &expression)
TTAProgram::Address	parseDataAddressExpression (const std::string &expression)
bool	parseBreakpoint (const std::vector< DataObject > &arguments, Breakpoint &target)
bool	askConditionFromUser (TclConditionScript &target)
bool	askExpressionFromUser (ExpressionScript &target)
bool	verifyBreakpointHandles (const std::vector< DataObject > &arguments, std::size_t startIndex=1)
void	setErrorMessage (const TCEString &errorMsg)
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)

Additional Inherited Members
Protected Member Functions inherited from SimControlLanguageCommand
bool	setMemoryAddress (const std::string &addressString, std::string &addressSpaceName, std::size_t &memoryAddress)
bool	setMemoryPointer (MemorySystem::MemoryPtr &memory, const std::string &addressSpaceName)

Detailed Description

Implementation of the "x" command of the Simulator Control Language.

Definition at line 47 of file MemDumpCommand.hh.

Constructor & Destructor Documentation

MemDumpCommand()

MemDumpCommand::MemDumpCommand

(

)

Constructor.

Sets the name of the command to the base class.

Definition at line 52 of file MemDumpCommand.cc.

                               : 
    SimControlLanguageCommand("x") {
}

~MemDumpCommand()

MemDumpCommand::~MemDumpCommand ( )

virtual

Destructor.

Does nothing.

Definition at line 61 of file MemDumpCommand.cc.

                                {
}

Member Function Documentation

execute()

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

virtual

Executes the "x" command.

This low-level command prints the data in memory starting at specified addresses addr.

Parameters

arguments

The address to print.

Returns

True in case simulation is initialized and arguments are ok.

Exceptions

NumberFormatException

Is never thrown by this command.

Implements CustomCommand.

Definition at line 75 of file MemDumpCommand.cc.

                                                              {
    static size_t displayedCount = 1;
    static size_t lastDisplayedAddress = 0;
    static size_t MAUsToDisplay = 1;
 
    const int argumentCount = arguments.size() - 1;
    if (!checkArgumentCount(argumentCount, 0, 9)) {
        return false;
    } 
 
    if (!checkProgramLoaded()) {
        return false;
    }
 
    bool illegalArguments = false;
    size_t newDisplayedCount = displayedCount;
    size_t newMAUCount = MAUsToDisplay;
    size_t newDisplayedAddress = lastDisplayedAddress + MAUsToDisplay;
    std::string addressSpaceName = "";
    std::string fileName = "";
    for (size_t i = 1; i < arguments.size(); ++i) {
        if (StringTools::ciEqual(arguments.at(i).stringValue(), "/n")) {
            if (i == arguments.size() - 1 || 
                !checkUnsignedIntegerArgument(arguments.at(i + 1))) {
                illegalArguments = true;
                break;
            }
            newDisplayedCount = 
                static_cast<size_t>(arguments.at(i + 1).integerValue());
            ++i;
        } else if (StringTools::ciEqual(arguments.at(i).stringValue(), "/u")) {
            if (i == arguments.size() - 1) {
                illegalArguments = true;
                break;
            }
            const std::string size = arguments.at(i + 1).stringValue();
            if (StringTools::ciEqual(size, "b")) {
                newMAUCount = 1;
            } else if (StringTools::ciEqual(size, "h")) {
                newMAUCount = 2;
            } else if (StringTools::ciEqual(size, "w")) {
                newMAUCount = 4;
            } else {
                illegalArguments = true;
                break;
            }
            ++i;
        } else if (StringTools::ciEqual(arguments.at(i).stringValue(), "/a")) {
            if (i == arguments.size() - 1) {
                illegalArguments = true;
                break;
            }
            addressSpaceName = arguments.at(i + 1).stringValue();
            ++i;
        } else if (StringTools::ciEqual(arguments.at(i).stringValue(), "/f")) {
            if (i == arguments.size() - 1) {
                illegalArguments = true;
                break;
            }
            fileName = arguments.at(i + 1).stringValue();
            ++i;
        } else if (i == arguments.size() - 1) {
            const std::string addressString = arguments.at(i).stringValue();
            if (!setMemoryAddress(
                    addressString, addressSpaceName, newDisplayedAddress)) {
                return false;
            }
        } else {
            illegalArguments = true;
            break;
        }
    }
 
    if (illegalArguments) {
        interpreter()->setResult(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_ILLEGAL_ARGUMENTS).str());
        interpreter()->setError(true);
        return false;
    }
 
    displayedCount = newDisplayedCount;
    lastDisplayedAddress = newDisplayedAddress;
 
    MemorySystem::MemoryPtr memory;
    if (!setMemoryPointer(memory, addressSpaceName)) {
        return false;
    }
 
    size_t MAUSize;
    if (simulatorFrontend().memorySystem().memoryCount() == 1) {
        MAUSize = simulatorFrontend().memorySystem().addressSpace(0).width();
    } else {
        MAUSize =
            simulatorFrontend().memorySystem().
            addressSpace(addressSpaceName).width();
    }
 
    if (MAUSize*newMAUCount > SIMULATOR_MAX_INTWORD_BITWIDTH) {
        interpreter()->setResult(
            (boost::format("Maximum printable integer size %d.") %
             SIMULATOR_MAX_INTWORD_BITWIDTH).str());
        interpreter()->setError(true);
        return false;        
    }
 
    std::ofstream* out = NULL;
    const bool dumpToFile = fileName != "";
    if (dumpToFile) {
        if (MAUSize != sizeof(char)*8) {
            interpreter()->setResult(
                (boost::format(
                    "Can only dump 8 bit memories to files. The given "
                    "address space is %d.") % MAUSize).str());
            interpreter()->setError(true);
            return false;
        }
        newMAUCount = 1;
        out = new std::ofstream(fileName.c_str(), std::ios::binary);
    }
 
    MAUsToDisplay = newMAUCount;
    DataObject* result = new DataObject("");
    // read the wanted number (given with /n) of chunks of data to the result 
    while (newDisplayedCount > 0) {
 
        ULongWord data = 0;
        try {
            memory->read(newDisplayedAddress, MAUsToDisplay, data);
        } catch (const OutOfRange&) {
            interpreter()->setResult(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_ADDRESS_OUT_OF_RANGE).str());
            interpreter()->setError(true);
            return false;        
        }
 
        
        newDisplayedCount--;
        newDisplayedAddress += MAUsToDisplay;
 
        if (!dumpToFile) {
            const int HEX_DIGITS = MAUSize*newMAUCount/4;
            result->setString(
                result->stringValue() + 
                Conversion::toHexString(data, HEX_DIGITS));
 
            if (newDisplayedCount > 0) {
                result->setString(result->stringValue() + " ");
            }
        } else {
            *out << (char)data;
        }
    }
 
    if (dumpToFile) {
        out->close();
        delete out;
        out = NULL;
    }
    interpreter()->setResult(result);
    return true;
}

References MemorySystem::addressSpace(), CustomCommand::checkArgumentCount(), SimControlLanguageCommand::checkProgramLoaded(), CustomCommand::checkUnsignedIntegerArgument(), StringTools::ciEqual(), CustomCommand::interpreter(), SimulatorFrontend::memorySystem(), ScriptInterpreter::setError(), SimControlLanguageCommand::setMemoryAddress(), SimControlLanguageCommand::setMemoryPointer(), ScriptInterpreter::setResult(), DataObject::setString(), SIMULATOR_MAX_INTWORD_BITWIDTH, SimControlLanguageCommand::simulatorFrontend(), DataObject::stringValue(), SimulatorToolbox::textGenerator(), Conversion::toHexString(), Texts::TXT_ADDRESS_OUT_OF_RANGE, Texts::TXT_ILLEGAL_ARGUMENTS, and TTAMachine::AddressSpace::width().

Here is the call graph for this function:

helpText()

std::string MemDumpCommand::helpText ( ) const

virtual

Returns the help text for this command.

Help text is searched from SimulatorTextGenerator.

Returns

The help text.

Implements CustomCommand.

Definition at line 247 of file MemDumpCommand.cc.

                               {
    return SimulatorToolbox::textGenerator().text(
        Texts::TXT_INTERP_HELP_X).str();
}

References Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), and Texts::TXT_INTERP_HELP_X.

Here is the call graph for this function:

---

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

• MemDumpCommand.hh
• MemDumpCommand.cc