#include <OperationContainer.hh>

Collaboration diagram for OperationContainer:

Public Member Functions
virtual	~OperationContainer ()

Static Public Member Functions
static OperationIndex &	operationIndex ()

static OperationSerializer &	operationSerializer ()

static OperationContext &	operationContext ()

static Memory &	memory ()

static void	destroy ()

static OperationModule &	module (const std::string &path, const std::string &mod)

static Operation *	operation (const std::string &path, const std::string &module, const std::string &oper)

static bool	operationExists (const std::string &name)

static bool	isEffective (OperationModule &module, const std::string &name)

static Word	memoryStart ()

static Word	memoryEnd ()

Private Member Functions
	OperationContainer ()

	OperationContainer (const OperationContainer &)
	Copying not allowed.

OperationContainer &	operator= (const OperationContainer &)
	Assignment not allowed.

Static Private Attributes
static const std::string	CREATE_FUNCTION = "createOpBehavior_"
	Creation function name for operation behavior.

static const std::string	DELETE_FUNCTION = "deleteOpBehavior_"
	Operation behavior deletion function name.

static const Word	MEMORY_START = 0
	Starting point of the memory.

static const Word	MEMORY_END = 65535
	End point of the memory.

static const Word	MAUSIZE = 8
	MAU size of the memory.

static OperationIndex *	index_ = NULL
	Contains information of operations.

static OperationSerializer *	serializer_ = NULL
	Static instance of operation serializer.

static OperationContext	context_
	Operation context used through the execution of the program.

static InstructionAddress	programCounter_
	Program counter.

static SimValue	returnAddress_
	Return address.

static SimValue	sysCallHandler_
	Sys call handler.

static SimValue	sysCallNumber_
	Sys call number.

static IdealSRAM *	memory_
	Memory used througout the execution of the program.

static PluginTools	tools_
	PluginTools used by OperationContainer;.

Detailed Description

Singleton class that holds necessary information for viewing operation properties, modifying operation behavior, and simulating operation behavior.

Include also means to view and modify the contents of the memory.

Definition at line 56 of file OperationContainer.hh.

Constructor & Destructor Documentation

◆ ~OperationContainer()

OperationContainer::~OperationContainer ( )

virtual

Destructor.

Definition at line 85 of file OperationContainer.cc.

85 {

86}

◆ OperationContainer() [1/2]

OperationContainer::OperationContainer ( )

private

Constructor.

Definition at line 79 of file OperationContainer.cc.

79 {

80}

◆ OperationContainer() [2/2]

OperationContainer::OperationContainer ( const OperationContainer & )

private

Copying not allowed.

Member Function Documentation

◆ destroy()

void OperationContainer::destroy ( )

static

This function is called to clean up the static objects.

This function should be called only when application is closed.

Definition at line 280 of file OperationContainer.cc.

                            {
    
    if (index_ != NULL) {
        delete index_;
        index_ = NULL;
    }
 
    if (serializer_ != NULL) {
        delete serializer_;
        serializer_ = NULL;
    }
 
    if (memory_ != NULL) {
        delete memory_;
        memory_ = NULL;
    }
}

References index_, memory_, and serializer_.

Referenced by OSEd::OnExit().

◆ isEffective()

bool OperationContainer::isEffective	(	OperationModule &	module,
		const std::string &	name
	)

static

Returns true if operation is effective.

Effective means that is is found first in list of search paths.

Parameters

module	The module in which operation is defined.
name	The name of the operation.

Returns: True if operation is effective.

Definition at line 244 of file OperationContainer.cc.

                           {
    
    try {
        OperationIndex& index = operationIndex();
        for (int i = 0; i < index.pathCount(); i++) {
            string path = index.path(i);
            for (int j = 0; j < index.moduleCount(path); j++) {
                OperationModule& mod = index.module(j, path);
                for (int k = 0; k < index.operationCount(mod); k++) {
                    string opName = index.operationName(k, mod);
                    if (opName == name) {
                        if (&module == &mod) {
                            return true;
                        } else {
                            return false;
                        }
                    }
                }
            }
        }
    } catch (const Exception& e) {
        return false;
    }
    // never should come here
    assert(false);
    return false;
}

References assert, module(), OperationIndex::module(), OperationIndex::moduleCount(), OperationIndex::operationCount(), operationIndex(), OperationIndex::operationName(), OperationIndex::path(), and OperationIndex::pathCount().

Referenced by OSEdInfoView::operationView().

Here is the call graph for this function:

◆ memory()

Memory & OperationContainer::memory ( )

static

Returns the memory model instance.

Returns: Memory model instance.

Definition at line 134 of file OperationContainer.cc.

                           {
    return *memory_;
}

References memory_.

Referenced by MemoryDialog::createContents(), and SimulateDialog::onAdvanceClock().

◆ memoryEnd()

Word OperationContainer::memoryEnd ( )

static

Returns the end point of the memory.

Returns: Memory end point.

Definition at line 314 of file OperationContainer.cc.

                              {
    return MEMORY_END;
}

References MEMORY_END.

◆ memoryStart()

Word OperationContainer::memoryStart ( )

static

Returns the start point of the memory.

Returns: Memory start point.

Definition at line 304 of file OperationContainer.cc.

                                {
    return MEMORY_START;
}

References MEMORY_START.

◆ module()

OperationModule & OperationContainer::module	(	const std::string &	path,
		const std::string &	mod
	)

static

Returns a certain module in a certain path.

If module is not found, a NullOperationModule is returned.

Parameters

path	The name of the path.
mod	The name of the module.

Returns: The module or NullOperationModule.

Definition at line 148 of file OperationContainer.cc.

                                                                      {
    OperationIndex& index = operationIndex();
    try {
        for (int i = 0; i < index.moduleCount(path); i++) {
            if (index.module(i, path).name() == mod) {
                return index.module(i, path);
            }
        }
    } catch (const Exception& e) {
        return NullOperationModule::instance();
    }
    return NullOperationModule::instance();
}

References NullOperationModule::instance(), OperationIndex::module(), OperationIndex::moduleCount(), OperationModule::name(), and operationIndex().

Referenced by isEffective(), AddModuleDialog::onOk(), and operation().

Here is the call graph for this function:

◆ operation()

Operation * OperationContainer::operation	(	const std::string &	path,
		const std::string &	mod,
		const std::string &	oper
	)

static

Returns a certain operation in a certain module and a path.

If operation is not found, NULL is returned.

Parameters

path	The name of the path.
mod	The name of the module.
oper	The name of the operation.

Returns: The operation.

Definition at line 173 of file OperationContainer.cc.

                           {
 
    OperationModule& opModule = module(path, mod);
    assert(&opModule != &NullOperationModule::instance());
 
    OperationSerializer& serializer = operationSerializer();
    serializer.setSourceFile(opModule.propertiesModule());
    try {
        ObjectState* root = serializer.readState();
        for (int i = 0; i < root->childCount(); i++) {
            if (root->child(i)->stringAttribute("name") == oper) {
 
                OperationIndex* index = new OperationIndex;
                index->addPath(path);
 
                Operation* op = 
                    new Operation(oper, NullOperationBehavior::instance());
                op->loadState(root->child(i));
 
                OperationBehaviorLoader* behaviorLoader = 
                    new OperationBehaviorLoader(*index);
                OperationBehaviorProxy* behaviorProxy = 
                    new OperationBehaviorProxy(*op, *behaviorLoader, true);
 
                op->setBehavior(*behaviorProxy);
 
                delete root;
                return op;
            }
        }
    } catch (const Exception& e) {
        return NULL;
    }
    return NULL;
}

References OperationIndex::addPath(), assert, ObjectState::child(), ObjectState::childCount(), NullOperationBehavior::instance(), NullOperationModule::instance(), Operation::loadState(), module(), operationSerializer(), OperationModule::propertiesModule(), OperationSerializer::readState(), Operation::setBehavior(), OperationSerializer::setSourceFile(), and ObjectState::stringAttribute().

Referenced by OSEdAddOperationCmd::Do(), OSEdInfoView::operationPropertyView(), OSEdTreeView::selectedOperation(), and OperationPropertyDialog::updateOperation().

Here is the call graph for this function:

◆ operationContext()

OperationContext & OperationContainer::operationContext ( )

static

Returns the instance of OperationContext.

Returns: Instance of OperationContext.

Definition at line 124 of file OperationContainer.cc.

                                     {
    return context_;
}

References context_.

Referenced by SimulateDialog::createState(), SimulateDialog::onAdvanceClock(), SimulateDialog::onReset(), SimulateDialog::onTrigger(), SimulateDialog::SimulateDialog(), and SimulateDialog::~SimulateDialog().

◆ operationExists()

bool OperationContainer::operationExists ( const std::string & name )

static

Returns true if operation exists.

Parameters

name	The name of the operation.

Returns: True if operation exists, false otherwise.

Definition at line 219 of file OperationContainer.cc.

                                                         {
    
    OperationIndex& index = operationIndex();
 
    for (int i = 0; i < index.moduleCount(); i++) {
        OperationModule& mod = index.module(i);
        for (int j = 0; j < index.operationCount(mod); j++) {
            if (index.operationName(j, mod) == name) {
                return true;
            }
        }
    }
    return false;
}

References OperationIndex::module(), OperationIndex::moduleCount(), OperationIndex::operationCount(), operationIndex(), and OperationIndex::operationName().

Referenced by OperationPropertyDialog::onAddAffectedBy(), and OperationPropertyDialog::onAddAffects().

Here is the call graph for this function:

◆ operationIndex()

OperationIndex & OperationContainer::operationIndex ( )

static

Returns the instance of OperationIndex.

Returns: The instance of OperationIndex.

Definition at line 94 of file OperationContainer.cc.

                                   {
    if (index_ == NULL) {
        index_ = new OperationIndex();
        vector<string> paths = Environment::osalPaths();
        for (size_t i = 0; i < paths.size(); i++) {
            index_->addPath(paths[i]);
        }
    }
    return *index_;
}

References OperationIndex::addPath(), index_, and Environment::osalPaths().

Referenced by OSEdTreeView::constructTree(), OSEdAddModuleCmd::Do(), OSEdAddOperationCmd::Do(), OSEdBuildAllCmd::Do(), OSEdPropertiesCmd::Do(), OSEdRemoveModuleCmd::Do(), OSEdRemoveOperationCmd::Do(), isEffective(), OSEdBuildAllCmd::isEnabled(), module(), OSEdInfoView::moduleView(), operationExists(), OSEdInfoView::operationView(), and OperationPropertyDialog::updateAffected().

Here is the call graph for this function:

◆ operationSerializer()

OperationSerializer & OperationContainer::operationSerializer ( )

static

Returns the instance of OperationSerializer.

Returns: The instance of OperationSerializer.

Definition at line 111 of file OperationContainer.cc.

                                        {
    if (serializer_ == NULL) {
        serializer_ = new OperationSerializer();
    }
    return *serializer_;
}

References serializer_.

Referenced by OSEdTreeView::constructTree(), OSEdAddModuleCmd::Do(), OSEdAddOperationCmd::Do(), OSEdPropertiesCmd::Do(), OSEdRemoveOperationCmd::Do(), and operation().

◆ operator=()

OperationContainer & OperationContainer::operator= ( const OperationContainer & )

private

Assignment not allowed.

Member Data Documentation

◆ context_

OperationContext OperationContainer::context_

staticprivate

Operation context used through the execution of the program.

Definition at line 107 of file OperationContainer.hh.

Referenced by operationContext().

◆ CREATE_FUNCTION

const string OperationContainer::CREATE_FUNCTION = "createOpBehavior_"

staticprivate

Creation function name for operation behavior.

Definition at line 91 of file OperationContainer.hh.

◆ DELETE_FUNCTION

const string OperationContainer::DELETE_FUNCTION = "deleteOpBehavior_"

staticprivate

Operation behavior deletion function name.

Definition at line 93 of file OperationContainer.hh.

◆ index_

OperationIndex * OperationContainer::index_ = NULL

staticprivate

Contains information of operations.

Definition at line 103 of file OperationContainer.hh.

Referenced by destroy(), and operationIndex().

◆ MAUSIZE

const Word OperationContainer::MAUSIZE = 8

staticprivate

MAU size of the memory.

Definition at line 100 of file OperationContainer.hh.

◆ memory_

IdealSRAM * OperationContainer::memory_

staticprivate

Initial value:

=

new IdealSRAM(MEMORY_START, MEMORY_END, MAUSIZE, false)

IdealSRAM

Definition IdealSRAM.hh:55

OperationContainer::MAUSIZE

static const Word MAUSIZE

MAU size of the memory.

Definition OperationContainer.hh:100

Memory used througout the execution of the program.

Definition at line 117 of file OperationContainer.hh.

Referenced by destroy(), and memory().

◆ MEMORY_END

const Word OperationContainer::MEMORY_END = 65535

staticprivate

End point of the memory.

Definition at line 98 of file OperationContainer.hh.

Referenced by memoryEnd().

◆ MEMORY_START

const Word OperationContainer::MEMORY_START = 0

staticprivate

Starting point of the memory.

Definition at line 96 of file OperationContainer.hh.

Referenced by memoryStart().

◆ programCounter_

InstructionAddress OperationContainer::programCounter_

staticprivate

Program counter.

Definition at line 109 of file OperationContainer.hh.

◆ returnAddress_

SimValue OperationContainer::returnAddress_

staticprivate

Return address.

Definition at line 111 of file OperationContainer.hh.

◆ serializer_

OperationSerializer * OperationContainer::serializer_ = NULL

staticprivate

Static instance of operation serializer.

Definition at line 105 of file OperationContainer.hh.

Referenced by destroy(), and operationSerializer().

◆ sysCallHandler_

SimValue OperationContainer::sysCallHandler_

staticprivate

Sys call handler.

Definition at line 113 of file OperationContainer.hh.

◆ sysCallNumber_

SimValue OperationContainer::sysCallNumber_

staticprivate

Sys call number.

Definition at line 115 of file OperationContainer.hh.

◆ tools_

PluginTools OperationContainer::tools_

staticprivate

PluginTools used by OperationContainer;.

Definition at line 119 of file OperationContainer.hh.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~OperationContainer()

◆ OperationContainer() [1/2]

◆ OperationContainer() [2/2]

Member Function Documentation

◆ destroy()

◆ isEffective()

◆ memory()

◆ memoryEnd()

◆ memoryStart()

◆ module()

◆ operation()

◆ operationContext()

◆ operationExists()

◆ operationIndex()

◆ operationSerializer()

◆ operator=()

Member Data Documentation

◆ context_

◆ CREATE_FUNCTION

◆ DELETE_FUNCTION

◆ index_

◆ MAUSIZE

◆ memory_

◆ MEMORY_END

◆ MEMORY_START

◆ programCounter_

◆ returnAddress_

◆ serializer_

◆ sysCallHandler_

◆ sysCallNumber_

◆ tools_