#include <SimControlLanguageCommand.hh>

Inheritance diagram for SimControlLanguageCommand:

Collaboration diagram for SimControlLanguageCommand:

Public Member Functions
	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

virtual bool	execute (const std::vector< DataObject > &arguments)=0

virtual std::string	helpText () const =0

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)

Protected Member Functions
bool	setMemoryAddress (const std::string &addressString, std::string &addressSpaceName, std::size_t &memoryAddress)

bool	setMemoryPointer (MemorySystem::MemoryPtr &memory, const std::string &addressSpaceName)

Detailed Description

This is a base class for Simulator Control Language commands.

Provides services command and useful for all Simulator Control Language commands.

Definition at line 63 of file SimControlLanguageCommand.hh.

Constructor & Destructor Documentation

◆ SimControlLanguageCommand()

SimControlLanguageCommand::SimControlLanguageCommand ( const std::string & name )

Constructor.

Sets the name of the command to the base class.

Parameters

name	Name of the command to add.

Definition at line 67 of file SimControlLanguageCommand.cc.

                           : 
    CustomCommand(name) {
}

◆ ~SimControlLanguageCommand()

SimControlLanguageCommand::~SimControlLanguageCommand ( )

virtual

Destructor.

Does nothing.

Definition at line 77 of file SimControlLanguageCommand.cc.

77 {

78}

Member Function Documentation

◆ askConditionFromUser()

bool SimControlLanguageCommand::askConditionFromUser ( TclConditionScript & target )

Prompts for a condition script from the user.

Also test runs the condition script. Returns false and sets interpreter error if the entered condition is illegal. If an empty condition script is entered, the condition script is set to always true "1" condition.

Parameters

target The target to put the condition script in.

Returns: false in case the script produces error when executed.

Definition at line 513 of file SimControlLanguageCommand.cc.

                                                                          {
 
    std::string conditionScript =  
        StringTools::trim(
            interpreter()->lineReader()->readLine(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_INTERP_ENTER_CONDITION_PROMPT).str()));
 
    if (StringTools::trim(conditionScript) == "") {
        conditionScript = "1";
    }
 
    TclConditionScript testCondition(
        dynamic_cast<TclInterpreter*>(interpreter()), conditionScript);
 
    // try the condition
    try {
        testCondition.execute();
        interpreter()->setResult("");
        target = testCondition;
    } catch (const ScriptExecutionFailure& sef) {
        interpreter()->setError(true);            
        return false;
    }   
    return true;
}

References Script::execute(), CustomCommand::interpreter(), ScriptInterpreter::setError(), ScriptInterpreter::setResult(), SimulatorToolbox::textGenerator(), StringTools::trim(), and Texts::TXT_INTERP_ENTER_CONDITION_PROMPT.

Referenced by ConditionCommand::execute(), and parseBreakpoint().

Here is the call graph for this function:

◆ askExpressionFromUser()

bool SimControlLanguageCommand::askExpressionFromUser ( ExpressionScript & target )

Prompts for an expression script from the user.

Also test runs the expression script. Returns false and sets interpreter error if the entered expression is illegal. If an empty expression script is entered, returns false and sets interpreter error.

Parameters

target The target to put the expression script in.

Returns: false in case the script produces error when executed or it's empty.

Definition at line 551 of file SimControlLanguageCommand.cc.

                                                                         {
 
    std::string expressionScript =  
        StringTools::trim(
            interpreter()->lineReader()->readLine(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_INTERP_ENTER_EXPRESSION_PROMPT).str()));
 
    if (StringTools::trim(expressionScript) == "") {
        interpreter()->setError(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_EXPRESSION_EMPTY).str());
        return false;
    }
 
    ExpressionScript testExpression(
        dynamic_cast<TclInterpreter*>(interpreter()), expressionScript);
 
    // try the condition
    try {
        testExpression.execute();
        interpreter()->setResult("");
        target = testExpression;
        return true;
    } catch (const ScriptExecutionFailure& sef) {
        interpreter()->setError(true);            
        return false;
    }   
}

References Script::execute(), CustomCommand::interpreter(), ScriptInterpreter::setError(), ScriptInterpreter::setResult(), SimulatorToolbox::textGenerator(), StringTools::trim(), Texts::TXT_EXPRESSION_EMPTY, and Texts::TXT_INTERP_ENTER_EXPRESSION_PROMPT.

Referenced by WatchCommand::execute().

Here is the call graph for this function:

◆ checkMachineLoaded()

bool SimControlLanguageCommand::checkMachineLoaded ( )

Checks that the simulated machine has been loaded successfully.

Returns: True if machine has been loaded.

Definition at line 199 of file SimControlLanguageCommand.cc.

                                              {
    if (!simulatorFrontend().isMachineLoaded()) {
        interpreter()->setError(std::string("No machine loaded."));
        return false;
    }
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setError(), and simulatorFrontend().

Here is the call graph for this function:

◆ checkProgramLoaded()

bool SimControlLanguageCommand::checkProgramLoaded ( )

Checks that the simulated program has been loaded successfully.

Returns: True if program has been loaded.

Definition at line 180 of file SimControlLanguageCommand.cc.

                                              {
 
    if (!simulatorFrontend().isProgramLoaded()) {
        interpreter()->setError(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_NO_PROGRAM_LOADED).str());
 
        return false;
    }
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setError(), simulatorFrontend(), SimulatorToolbox::textGenerator(), and Texts::TXT_NO_PROGRAM_LOADED.

Referenced by DisassembleCommand::execute(), MemDumpCommand::execute(), MemWriteCommand::execute(), and SymbolAddressCommand::execute().

Here is the call graph for this function:

◆ checkSimulationEnded()

bool SimControlLanguageCommand::checkSimulationEnded ( )

Checks that the simulation has ended.

Sets errors message and returns false if simulation has not ended.

Returns: True if simulation has ended.

Definition at line 158 of file SimControlLanguageCommand.cc.

                                                {
 
    DataObject* result = new DataObject();
    if (!simulatorFrontend().hasSimulationEnded()) {
        result->setString(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_INTERP_SIMULATION_NOT_ENDED).str());
        interpreter()->setResult(result);
        return false;
    }    
    
    interpreter()->setResult(result);
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setResult(), DataObject::setString(), simulatorFrontend(), SimulatorToolbox::textGenerator(), and Texts::TXT_INTERP_SIMULATION_NOT_ENDED.

Referenced by KillCommand::execute().

Here is the call graph for this function:

◆ checkSimulationInitialized()

bool SimControlLanguageCommand::checkSimulationInitialized ( )

Checks that the simulation is initialized and ready to run.

Sets errors message and returns false if simulation is not initialized.

Returns: True if simulation is initialized.

Definition at line 88 of file SimControlLanguageCommand.cc.

                                                      {
 
    DataObject* result = new DataObject();        
    if (!simulatorFrontend().isSimulationInitialized()) {
        result->setString(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_INTERP_SIMULATION_NOT_INITIALIZED).str());
        interpreter()->setResult(result);
        return false;
    }
 
    interpreter()->setResult(result);
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setResult(), DataObject::setString(), simulatorFrontend(), SimulatorToolbox::textGenerator(), and Texts::TXT_INTERP_SIMULATION_NOT_INITIALIZED.

Referenced by ConditionCommand::execute(), DeleteBPCommand::execute(), DisableBPCommand::execute(), EnableBPCommand::execute(), IgnoreCommand::execute(), NextiCommand::execute(), RunCommand::execute(), StepiCommand::execute(), UntilCommand::execute(), and parseBreakpoint().

Here is the call graph for this function:

◆ checkSimulationNotAlreadyRunning()

bool SimControlLanguageCommand::checkSimulationNotAlreadyRunning ( )

Checks that the simulation is not already running.

Sets errors message and returns false if simulation is running.

Returns: True if simulation is not running.

Definition at line 111 of file SimControlLanguageCommand.cc.

                                                            {
 
    DataObject* result = new DataObject();
    if (simulatorFrontend().isSimulationRunning() || 
        simulatorFrontend().isSimulationStopped()) {
        result->setString(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_INTERP_SIMULATION_ALREDY_RUNNING).str());
        interpreter()->setResult(result);
        return false;
    }    
    interpreter()->setResult(result);        
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setResult(), DataObject::setString(), simulatorFrontend(), SimulatorToolbox::textGenerator(), and Texts::TXT_INTERP_SIMULATION_ALREDY_RUNNING.

Referenced by RunCommand::execute().

Here is the call graph for this function:

◆ checkSimulationStopped()

bool SimControlLanguageCommand::checkSimulationStopped ( )

Checks that the simulation is stopped.

Sets errors message and returns false if simulation is not stopped by the user.

Returns: True if simulation is stopped.

Definition at line 135 of file SimControlLanguageCommand.cc.

                                                  {
 
    DataObject* result = new DataObject();
    if (!simulatorFrontend().isSimulationStopped()) {
        result->setString(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_INTERP_SIMULATION_NOT_RUNNING).str());
        interpreter()->setResult(result);
        return false;
    }    
 
    interpreter()->setResult(result);
    return true;
}

References CustomCommand::interpreter(), ScriptInterpreter::setResult(), DataObject::setString(), simulatorFrontend(), SimulatorToolbox::textGenerator(), and Texts::TXT_INTERP_SIMULATION_NOT_RUNNING.

Referenced by BackTraceCommand::execute(), ConditionCommand::execute(), DeleteBPCommand::execute(), DisableBPCommand::execute(), EnableBPCommand::execute(), IgnoreCommand::execute(), KillCommand::execute(), NextiCommand::execute(), ResumeCommand::execute(), StepiCommand::execute(), UntilCommand::execute(), and parseBreakpoint().

Here is the call graph for this function:

◆ outputStream()

std::ostream & SimControlLanguageCommand::outputStream ( )

virtual

Returns the output stream which can be used to print information to the user.

Uses the same output stream as the linereader to make the information texts printed to the same stream as confirmations of the linereader.

Returns: The output stream.

Definition at line 351 of file SimControlLanguageCommand.cc.

                                        {
    return interpreter()->lineReader()->outputStream();
}

References CustomCommand::interpreter(), ScriptInterpreter::lineReader(), and LineReader::outputStream().

Referenced by BackTraceCommand::execute(), CommandsCommand::execute(), DisassembleCommand::execute(), HelpCommand::execute(), InfoProcCommand::execute(), InfoProgramCommand::execute(), ProgCommand::execute(), SettingCommand::execute(), printBreakpointInfo(), printNextInstruction(), printSimulationTime(), and printStopReasons().

Here is the call graph for this function:

◆ parseBreakpoint()

bool SimControlLanguageCommand::parseBreakpoint	(	const std::vector< DataObject > &	arguments,
		Breakpoint &	target
	)

Parses breakpoint data from the given arguments.

This is a refactoring of common functionality used in 'bp' and 'tbp' commands. Sets the error message to the interpreter and returns false if there was an error while parsing or simulation is in wrong state.

Parameters

arguments	as passed to the execute() of the command.
target	the breakpoint instance to put the parsed data to.

Returns: true if the breakpoint was parsed succesfully.

Todo:: set the condition, if any

Definition at line 593 of file SimControlLanguageCommand.cc.

                                                                {
 
    if (!checkSimulationInitialized() && !checkSimulationStopped()) {
        return false;
    }
 
    // how many arguments there are in the condition part
    size_t conditionArgumentCount = 0;
    for (size_t i = 0; i < arguments.size(); ++i) {
        if (StringTools::stringToLower(arguments[i].stringValue()) ==
            "if") {
 
            if (i != arguments.size() - 1) {
                interpreter()->setError(
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_ARGUMENTS).str());
                return false;
            }
            conditionArgumentCount = 1;
            break;
        }
    }
 
    if (conditionArgumentCount > 0) {
        TclConditionScript condition(NULL, "");
        if (!askConditionFromUser(condition)) {
            return false;
        }
        assert(condition.script().size() > 0);
        if (condition.script().at(0) == "1") {
            target.removeCondition();
        } else {
            target.setCondition(condition);
        }
    }
 
    const int argumentsBeforeCondition = 
        arguments.size() - 1 - conditionArgumentCount;
 
    InstructionAddress theAddress = 0;
 
    if (argumentsBeforeCondition == 0 || argumentsBeforeCondition == 1) {
 
        const std::string argument = 
            ((argumentsBeforeCondition == 0)?
             (""):(arguments[1].stringValue()));
        try {
            theAddress = 
                parseInstructionAddressExpression(argument);
        } catch (const IllegalParameters&) {
            // the helper function has set the error string to 
            // the interpreter
            return false;
        }
        
    } else {
        interpreter()->setError(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_ILLEGAL_ARGUMENTS).str());
        return false;
    }
 
    /// @todo set the condition, if any
    
    target.setAddress(theAddress);
    return true;
}

References askConditionFromUser(), assert, checkSimulationInitialized(), checkSimulationStopped(), CustomCommand::interpreter(), parseInstructionAddressExpression(), StopPoint::removeCondition(), TclConditionScript::script(), Breakpoint::setAddress(), StopPoint::setCondition(), ScriptInterpreter::setError(), StringTools::stringToLower(), SimulatorToolbox::textGenerator(), and Texts::TXT_ILLEGAL_ARGUMENTS.

Referenced by BPCommand::execute(), and TBPCommand::execute().

Here is the call graph for this function:

◆ parseDataAddressExpression()

TTAProgram::Address SimControlLanguageCommand::parseDataAddressExpression ( const std::string & expression )

Parses a data address expression string.

Expression string can be given by the user to, for example, 'x' command. Resolves symbol.

Supported address expression strings are currently:

*address An absolute address reference, can be an integer or a label string. In case of a label string, the return value contains also the address space of the address expression.

Parameters

expression The expression to parse.

Returns: The parsed instruction address and its address space, if given. In case address space could not be found, the address space field points to NullAddressSpace.

Exceptions

IllegalParameters when expression could not be parsed to an address.

Definition at line 471 of file SimControlLanguageCommand.cc.

                                 {
    std::string expr = StringTools::trim(expression);
    const std::string errorMessage = "Illegal argument.";
 
    InstructionAddress theAddress = 0;
 
    // check if it's an integer, that is, a direct address reference
    const std::string addressString = expression;
    try {
        theAddress = Conversion::toUnsignedInt(expression);
    } catch (const NumberFormatException&) {
        // it was not an integer, check if a label with given string 
        // is found in the global scope
        const GlobalScope& globalScope = 
            simulatorFrontend().program().globalScopeConst();
        
        try {
            return globalScope.dataLabel(expression).address();
        } catch (const KeyNotFound&) {
            // couldn't evaluate the label 
            interpreter()->setError(
                SimulatorToolbox::textGenerator().text(
                        Texts::TXT_LABEL_NOT_FOUND).str());
            throw IllegalParameters(
                __FILE__, __LINE__, __func__, errorMessage);
        }
    }
    return Address(theAddress, TTAMachine::NullAddressSpace::instance());
}

References __func__, TTAProgram::Label::address(), TTAProgram::Scope::dataLabel(), TTAProgram::Program::globalScopeConst(), TTAMachine::NullAddressSpace::instance(), CustomCommand::interpreter(), SimulatorFrontend::program(), ScriptInterpreter::setError(), simulatorFrontend(), SimulatorToolbox::textGenerator(), Conversion::toUnsignedInt(), StringTools::trim(), and Texts::TXT_LABEL_NOT_FOUND.

Referenced by setMemoryAddress().

Here is the call graph for this function:

◆ parseInstructionAddressExpression()

InstructionAddress SimControlLanguageCommand::parseInstructionAddressExpression ( const std::string & expression )

Parses an instruction address expression string.

Expression string can be given by the user to, for example, 'break' or 'until' commands. This function also does range checking, when the address is lower than the first address of the program, it sets the address to the lowest address, when the address is bigger than the last address of the program, it sets the address to the last address.

Supported address expression strings are currently:

[empty] Address of the instruction following the current instruction. *address An absolute instruction address reference, can be an integer or a label string.

Parameters

expression The expression to parse.

Returns: The parsed instruction address.

Exceptions

IllegalParameters when expression could not be parsed to an address.

Definition at line 378 of file SimControlLanguageCommand.cc.

                                 {
    std::string expr = StringTools::trim(expression);
    const std::string errorMessage = "Illegal argument.";
 
    InstructionAddress theAddress = 0;
    if (expr.size() == 0) {
        theAddress = simulatorFrontend().programCounter() + 1;
    } else {
        // the argument is an absolute address, try to evaluate it to an
        // instruction address 
 
        // check if it's an integer, that is, a direct instruction address
        // reference
        const std::string address = expression;
        try {
            theAddress = Conversion::toUnsignedInt(address);
        } catch (const NumberFormatException&) {
            // check if a label with given string is found in the
            // global scope
            const GlobalScope& globalScope = 
                simulatorFrontend().program().globalScopeConst();
 
            try {
                theAddress = 
                    globalScope.codeLabel(address).address().location();
            } catch (const KeyNotFound&) {
                try {
                    // check if it's a reference to a function
                    theAddress = 
                        simulatorFrontend().program().procedure(address).
                        startAddress().location();
                } catch (const KeyNotFound&) {
                    try {
                        // check if user forgot the leading "_"
                        theAddress = 
                            simulatorFrontend().program().procedure(
                                std::string("_") + address).
                            startAddress().location();
                    } catch (const KeyNotFound&) {
                        // couldn't evaluate the label 
                        interpreter()->setError(
                            SimulatorToolbox::textGenerator().text(
                            Texts::TXT_LABEL_NOT_FOUND).str());
                        
                        throw IllegalParameters(
                            __FILE__, __LINE__, __func__, errorMessage);
                    }
                }
            }
        }
    }
 
    // check the boundaries of the instruction address and fix it, if necessary
    const InstructionAddress programLastAddress = 
        simulatorFrontend().program().lastProcedure().endAddress().location() 
        - 1;
 
    const InstructionAddress programFirstAddress = 
        simulatorFrontend().program().firstProcedure().startAddress().
        location();
    
    if (theAddress > programLastAddress) {
        theAddress = programLastAddress;
    } else if (theAddress < programFirstAddress) {
        theAddress = programFirstAddress;
    }
 
    return theAddress;
}

References __func__, TTAProgram::CodeLabel::address(), TTAProgram::Scope::codeLabel(), TTAProgram::CodeSnippet::endAddress(), TTAProgram::Program::firstProcedure(), TTAProgram::Program::globalScopeConst(), CustomCommand::interpreter(), TTAProgram::Program::lastProcedure(), TTAProgram::Address::location(), TTAProgram::Program::procedure(), SimulatorFrontend::program(), SimulatorFrontend::programCounter(), ScriptInterpreter::setError(), simulatorFrontend(), TTAProgram::CodeSnippet::startAddress(), SimulatorToolbox::textGenerator(), Conversion::toUnsignedInt(), StringTools::trim(), and Texts::TXT_LABEL_NOT_FOUND.

Referenced by DisassembleCommand::execute(), UntilCommand::execute(), and parseBreakpoint().

Here is the call graph for this function:

◆ printBreakpointInfo()

bool SimControlLanguageCommand::printBreakpointInfo ( unsigned int breakpointHandle )

virtual

Prints information of a breakpoint.

If breakpoint with the given handle could not be found, sets error to the interpreter and returns false.

Parameters

breakpointHandle The handle of the breakpoint to be printed.

Returns: true If breakpoint could be printed.

Definition at line 678 of file SimControlLanguageCommand.cc.

                                   {
 
    try {
        const StopPoint& stopPoint = 
            simulatorFrontend().stopPointManager().stopPointWithHandleConst(
                breakpointHandle);
 
        outputStream() 
            << std::right << std::setw(BPINFO_HANDLE_COL_WIDTH) 
            << breakpointHandle << ": " << stopPoint.description() 
            << std::endl;
 
        return true;
    } catch (const InstanceNotFound&) {
        interpreter()->setError(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_BREAKPOINT_NOT_FOUND).str());
        return false;
    }
}

References BPINFO_HANDLE_COL_WIDTH, StopPoint::description(), CustomCommand::interpreter(), outputStream(), ScriptInterpreter::setError(), simulatorFrontend(), SimulatorFrontend::stopPointManager(), StopPointManager::stopPointWithHandleConst(), SimulatorToolbox::textGenerator(), and Texts::TXT_BREAKPOINT_NOT_FOUND.

Referenced by BPCommand::execute(), ConditionCommand::execute(), DisableBPCommand::execute(), EnableBPCommand::execute(), IgnoreCommand::execute(), InfoBreakpointsCommand::execute(), TBPCommand::execute(), and WatchCommand::execute().

Here is the call graph for this function:

◆ printNextInstruction()

void SimControlLanguageCommand::printNextInstruction ( )

virtual

Prints the next simulated instruction to the simulator console.

Definition at line 228 of file SimControlLanguageCommand.cc.

                                                {
 
    if (simulatorFrontend().nextInstructionPrinting())    
        outputStream() << simulatorFrontend().programLocationDescription() 
                       << std::endl;
}

References outputStream(), SimulatorFrontend::programLocationDescription(), and simulatorFrontend().

Referenced by NextiCommand::execute(), StepiCommand::execute(), UntilCommand::execute(), and printStopInformation().

Here is the call graph for this function:

◆ printSimulationTime()

void SimControlLanguageCommand::printSimulationTime ( )

virtual

Prints the simulation time in minutes and seconds in case it's enabled.

Also prints out the frequency in MHz

Definition at line 322 of file SimControlLanguageCommand.cc.

                                               {        
 
    if (!simulatorFrontend().simulationTimeStatistics())
        return;
 
    ClockCycleCount cycleCount = simulatorFrontend().lastRunCycleCount();    
    double time = simulatorFrontend().lastRunTime();
 
    double minutes = 0.0;
    double seconds = modf(time / 60.0 , &minutes) * 60.0;
    double frequency = (static_cast<double>(cycleCount) / time) / 1000000;
 
        
    outputStream() 
        << minutes << " min "
        << seconds << " s "
        << frequency << " MHz" << std::endl;
}

References SimulatorFrontend::lastRunCycleCount(), SimulatorFrontend::lastRunTime(), outputStream(), and simulatorFrontend().

Referenced by StepiCommand::execute(), UntilCommand::execute(), and printStopInformation().

Here is the call graph for this function:

◆ printStopInformation()

void SimControlLanguageCommand::printStopInformation ( )

virtual

Prints information that should be printed after simulation is stopped.

These should be printed when the control is returned back to user after running simulation with "run" or "resume" commands and being stopped due to simulation finish or a breakpoint.

Definition at line 243 of file SimControlLanguageCommand.cc.

                                                {
 
    printNextInstruction();
    printStopReasons();
    printSimulationTime();
}

References printNextInstruction(), printSimulationTime(), and printStopReasons().

Referenced by ResumeCommand::execute(), and RunCommand::execute().

Here is the call graph for this function:

◆ printStopReasons()

void SimControlLanguageCommand::printStopReasons ( )

virtual

Prints the reasons why simulation has been stopped.

Todo:: the stop reason code to string conversion should be externalized to another function.

Definition at line 257 of file SimControlLanguageCommand.cc.

                                            {
    for (unsigned int i = 0; i < simulatorFrontend().stopReasonCount(); ++i) {
        switch (simulatorFrontend().stopReason(i)) {
        case SRE_AFTER_STEPPING:
            outputStream() 
                << SimulatorToolbox::textGenerator().text(
                    Texts::TXT_STOPREASON_STEPPING).str() << std::endl;
            break;
        case SRE_AFTER_UNTIL:
            outputStream() 
                << SimulatorToolbox::textGenerator().text(
                    Texts::TXT_STOPREASON_UNTIL).str() << std::endl;
            break;
        case SRE_AFTER_TIMEOUT:
            outputStream()
                << SimulatorToolbox::textGenerator().text(
                    Texts::TXT_STOPREASON_TIMEOUT).str() << std::endl;
            break;
        case SRE_USER_REQUESTED:
            outputStream() 
                << SimulatorToolbox::textGenerator().text(
                    Texts::TXT_STOPREASON_USERREQUEST).str() << std::endl;
            break;
        case SRE_RUNTIME_ERROR:
            outputStream() 
                << SimulatorToolbox::textGenerator().text(
                    Texts::TXT_STOPREASON_RUNTIME_ERROR).str() << std::endl;
            break;
        case SRE_BREAKPOINT: {
             StopPointManager& stopPointManager = 
                simulatorFrontend().stopPointManager();
            for (unsigned int i = 0; 
                 i < stopPointManager.stopCausingStopPointCount(); ++i) {
                try {
                    // test that the breakpoint is not deleted
                    stopPointManager.stopPointWithHandleConst(
                        stopPointManager.stopCausingStopPoint(i));
                    outputStream() 
                        << (SimulatorToolbox::textGenerator().text(
                                Texts::TXT_STOPREASON_BREAKPOINT) % 
                            stopPointManager.stopCausingStopPoint(i)).str()
                        << std::endl;
                } catch (const InstanceNotFound&) {
                    outputStream() 
                        << SimulatorToolbox::textGenerator().text(
                            Texts::TXT_STOPREASON_DELETED_BREAKPOINT).str()
                        << std::endl;
                }
            }
            break;
        }
        default:
            outputStream() 
                << "Stopped because of an unknown reason." << std::endl;
            break;
        }
    }
}

References outputStream(), simulatorFrontend(), SRE_AFTER_STEPPING, SRE_AFTER_TIMEOUT, SRE_AFTER_UNTIL, SRE_BREAKPOINT, SRE_RUNTIME_ERROR, SRE_USER_REQUESTED, StopPointManager::stopCausingStopPoint(), StopPointManager::stopCausingStopPointCount(), SimulatorFrontend::stopPointManager(), StopPointManager::stopPointWithHandleConst(), SimulatorFrontend::stopReason(), SimulatorFrontend::stopReasonCount(), Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), Texts::TXT_STOPREASON_BREAKPOINT, Texts::TXT_STOPREASON_DELETED_BREAKPOINT, Texts::TXT_STOPREASON_RUNTIME_ERROR, Texts::TXT_STOPREASON_STEPPING, Texts::TXT_STOPREASON_TIMEOUT, Texts::TXT_STOPREASON_UNTIL, and Texts::TXT_STOPREASON_USERREQUEST.

Referenced by InfoProgramCommand::execute(), and printStopInformation().

Here is the call graph for this function:

◆ setErrorMessage()

void SimControlLanguageCommand::setErrorMessage ( const TCEString & errorMsg )

Definition at line 738 of file SimControlLanguageCommand.cc.

                                                                    {
    DataObject* errorMessage = new DataObject();
    errorMessage->setString(errorMsg);
    interpreter()->setResult(errorMessage);
}

References CustomCommand::interpreter(), ScriptInterpreter::setResult(), and DataObject::setString().

Referenced by BackTraceCommand::execute().

Here is the call graph for this function:

◆ setMemoryAddress()

bool SimControlLanguageCommand::setMemoryAddress	(	const std::string &	addressString,
		std::string &	addressSpaceName,
		std::size_t &	memoryAddress
	)

protected

Parses the address string to corresponding memory address and address space.

Parameters

addressString	Memory address command string to parse.
addressSpaceName	Address space name to be set.
memoryAddress	Memory address to be set.

Returns: true on success.

Definition at line 753 of file SimControlLanguageCommand.cc.

                              {
 
    try {
        const TTAProgram::Address& parsedAddress =
            parseDataAddressExpression(addressString);
        if (&parsedAddress.space() !=
            &TTAMachine::NullAddressSpace::instance()) {
            addressSpaceName = parsedAddress.space().name();
        }
        memoryAddress = parsedAddress.location();
    } catch(const IllegalParameters& n) {
        return false;
    }
    return true;
}

References TTAMachine::NullAddressSpace::instance(), TTAProgram::Address::location(), TTAMachine::Component::name(), parseDataAddressExpression(), and TTAProgram::Address::space().

Referenced by MemDumpCommand::execute(), and MemWriteCommand::execute().

Here is the call graph for this function:

◆ setMemoryPointer()

bool SimControlLanguageCommand::setMemoryPointer	(	MemorySystem::MemoryPtr &	memory,
		const std::string &	addressSpaceName
	)

protected

Sets memory instance from a given AddressSpaceName to given memory.

Parameters

memory	Memory pointer to be set
addressSpaceName	The name of the address space.

Returns: true on success.

must have the address space defined

Definition at line 780 of file SimControlLanguageCommand.cc.

                                       {
 
    if (simulatorFrontend().memorySystem().memoryCount() < 1) {
        interpreter()->setError(
            SimulatorToolbox::textGenerator().text(
                Texts::TXT_ADDRESS_SPACE_NOT_FOUND).str());
        return false;
    } else if (simulatorFrontend().memorySystem().memoryCount() == 1) {
        memory = simulatorFrontend().memorySystem().memory(0);
    } else {
        /// must have the address space defined
        if (addressSpaceName == "") {
            interpreter()->setError(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_NO_ADDRESS_SPACE_GIVEN).str());
            return false;
        }
        try {
            memory =
                simulatorFrontend().memorySystem().memory(addressSpaceName);
        } catch (const InstanceNotFound&) {
            interpreter()->setError(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_ADDRESS_SPACE_NOT_FOUND).str());
            return false;
        }
    }
    return true;
}

References CustomCommand::interpreter(), MemorySystem::memory(), SimulatorFrontend::memorySystem(), ScriptInterpreter::setError(), simulatorFrontend(), SimulatorToolbox::textGenerator(), Texts::TXT_ADDRESS_SPACE_NOT_FOUND, and Texts::TXT_NO_ADDRESS_SPACE_GIVEN.

Referenced by MemDumpCommand::execute(), and MemWriteCommand::execute().

Here is the call graph for this function:

◆ simulatorFrontend()

SimulatorFrontend & SimControlLanguageCommand::simulatorFrontend ( )

Returns the SimulatorFrontend instance stored in the context.

Returns: The SimulatorFrontend instance.

Definition at line 214 of file SimControlLanguageCommand.cc.

                                             {
 
    assert(interpreter() != NULL);
    
    SimulatorInterpreterContext& interpreterContext = 
        dynamic_cast<SimulatorInterpreterContext&>(interpreter()->context());
    
    return interpreterContext.simulatorFrontend();    
}

References assert, ScriptInterpreter::context(), CustomCommand::interpreter(), and SimulatorInterpreterContext::simulatorFrontend().

Here is the call graph for this function:

◆ simulatorFrontendConst()

const SimulatorFrontend & SimControlLanguageCommand::simulatorFrontendConst ( )

◆ verifyBreakpointHandles()

bool SimControlLanguageCommand::verifyBreakpointHandles	(	const std::vector< DataObject > &	arguments,
		std::size_t	startIndex = `1`
	)

Verifies that the list of breakpoint ids are valid breakpoint handles.

A refactoring for error checking of the {enable,disable,delete}bp commands. Sets interpreter error in case invalid handles are found and returns false.

Parameters

arguments	The arguments as given to the execute() of the command.
startIndex	The first argument to check.

Returns: true if all handles are valid.

Definition at line 712 of file SimControlLanguageCommand.cc.

                          {
    
    // verify that the breakpoints are found
    for (size_t i = startIndex; i < arguments.size(); ++i) {
        if (!checkPositiveIntegerArgument(arguments[i])) {
            return false;
        }
        const unsigned int breakpointHandle = arguments[i].integerValue();
        try {
            StopPointManager& stopPointManager =
                simulatorFrontend().stopPointManager();
            // just check that breakpoint is found with the handle
            stopPointManager.stopPointWithHandleConst(breakpointHandle);
        } catch (const InstanceNotFound&) {
            interpreter()->setError(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_BREAKPOINT_NOT_FOUND).str());
            return false;
        }
    }
    return true;
}

References CustomCommand::checkPositiveIntegerArgument(), CustomCommand::interpreter(), ScriptInterpreter::setError(), simulatorFrontend(), SimulatorFrontend::stopPointManager(), StopPointManager::stopPointWithHandleConst(), SimulatorToolbox::textGenerator(), and Texts::TXT_BREAKPOINT_NOT_FOUND.

Referenced by DeleteBPCommand::execute(), DisableBPCommand::execute(), and EnableBPCommand::execute().

Here is the call graph for this function:

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

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SimControlLanguageCommand()

◆ ~SimControlLanguageCommand()

Member Function Documentation

◆ askConditionFromUser()

◆ askExpressionFromUser()

◆ checkMachineLoaded()

◆ checkProgramLoaded()

◆ checkSimulationEnded()

◆ checkSimulationInitialized()

◆ checkSimulationNotAlreadyRunning()

◆ checkSimulationStopped()

◆ outputStream()

◆ parseBreakpoint()

◆ parseDataAddressExpression()

◆ parseInstructionAddressExpression()

◆ printBreakpointInfo()

◆ printNextInstruction()

◆ printSimulationTime()

◆ printStopInformation()

◆ printStopReasons()

◆ setErrorMessage()

◆ setMemoryAddress()

◆ setMemoryPointer()

◆ simulatorFrontend()

◆ simulatorFrontendConst()

◆ verifyBreakpointHandles()