#include <OperationDAGBuilder.hh>

Collaboration diagram for OperationDAGBuilder:

Public Member Functions
	OperationDAGBuilder (const OperationPimpl &operation, OperationDAG &dag, const TokenizerData::TokenTreeNode &root)

void	parse ()

Private Types
typedef std::pair< OperationDAGNode *, int >	VariableBinding
	Node and operand which is referred by a variable. More...

typedef std::pair< TerminalNode *, unsigned int >	TerminalBinding
	Information of object and index of operand of a variable. More...

Private Member Functions
void	parseNode (const TokenizerData::TokenTreeNode *node)

void	createOperationNode (const std::string &operation)

void	connectOperandToNode (const TokenizerData::TokenTreeNode *var, unsigned int operandIndex)

void	finalize ()

void	declareVariable (const TokenizerData::TokenTreeNode *var)

void	assignVariable (const TokenizerData::TokenTreeNode *dst, VariableBinding &src)

void	assignVariable (const TokenizerData::TokenTreeNode dst, const TokenizerData::TokenTreeNode src)

std::string	getVariableName (const TokenizerData::TokenTreeNode *var)

VariableBinding &	getBinding (const TokenizerData::TokenTreeNode *var)

VariableBinding &	getBinding (std::string varName)

VariableBinding &	getBinding (unsigned int operandIndex)

VariableBinding &	getConstantBinding (long value)

unsigned int	getIOOperand (const TokenizerData::TokenTreeNode *var)

Private Attributes
OperationDAG *	dag_
	DAG where all nodes and edges are added. More...

const TokenizerData::TokenTreeNode &	rootNode_
	Root of tokenized data parsed from OSAL DAG source code. More...

OperationNode *	currentOperation_
	Currently created handled operation. More...

std::map< std::string, VariableBinding >	variableBindings_
	Node and operand which are referred by IO(x) or declared variable. More...

std::map< long, VariableBinding >	constantBindings_
	Node representing constant value. More...

std::map< std::string, TerminalBinding >	ioVariables_
	IO(x) variables and corresponding TerminalNodes and operand indices. More...

const OperationPimpl &	operation_

Detailed Description

Builds OperationDAG from parsed and tokenized OSAL code.

Definition at line 47 of file OperationDAGBuilder.hh.

Member Typedef Documentation

◆ TerminalBinding

typedef std::pair<TerminalNode*, unsigned int> OperationDAGBuilder::TerminalBinding

private

Information of object and index of operand of a variable.

Definition at line 61 of file OperationDAGBuilder.hh.

◆ VariableBinding

typedef std::pair<OperationDAGNode*, int> OperationDAGBuilder::VariableBinding

private

Node and operand which is referred by a variable.

Definition at line 58 of file OperationDAGBuilder.hh.

Constructor & Destructor Documentation

◆ OperationDAGBuilder()

OperationDAGBuilder::OperationDAGBuilder	(	const OperationPimpl &	operation,
		OperationDAG &	dag,
		const TokenizerData::TokenTreeNode &	root
	)

Constructor.

Parameters

dag	OperationDAG where to create DAG representation of operation.
root	Tokenized OSAL DAG Language code.

Definition at line 53 of file OperationDAGBuilder.cc.

                                                                : 
     dag_(&dag), rootNode_(root), currentOperation_(NULL), 
     operation_(operation) { 
 }

Member Function Documentation

◆ assignVariable() [1/2]

void OperationDAGBuilder::assignVariable	(	const TokenizerData::TokenTreeNode *	dst,
		const TokenizerData::TokenTreeNode *	src
	)

private

Assign binding of destination variable to be same than source.

Parameters

src	Tree node variable whose binding is set to destination.
dst	Tree node variable whose binding is set to same that source's.

Definition at line 311 of file OperationDAGBuilder.cc.

                                            {
     std::string dstName = getVariableName(dst);
     variableBindings_[dstName] = getBinding(src);
 }     

References getBinding(), getVariableName(), and variableBindings_.

Here is the call graph for this function:

◆ assignVariable() [2/2]

void OperationDAGBuilder::assignVariable	(	const TokenizerData::TokenTreeNode *	dst,
		VariableBinding &	src
	)

private

Assign binding of destination variable to be source binding.

Parameters

src	Tree node variable whose binding is set to destination.
dst	Binding that is set to source's binding.

Definition at line 289 of file OperationDAGBuilder.cc.

                                                                  {
     std::string dstName = getVariableName(dst);
  
     if (variableBindings_.find(dstName) == variableBindings_.end() && 
         ioVariables_.find(dstName) == ioVariables_.end()) {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__,
             "Variable \"" + dst->token().stringValue() + 
             "\" was not declared.");
     }
  
     variableBindings_[dstName] = src;
 }     

References __func__, getVariableName(), ioVariables_, TokenizerData::Token::stringValue(), TokenizerData::TokenTreeNode::token(), and variableBindings_.

Referenced by connectOperandToNode(), and parseNode().

Here is the call graph for this function:

◆ connectOperandToNode()

void OperationDAGBuilder::connectOperandToNode	(	const TokenizerData::TokenTreeNode *	var,
		unsigned int	operandIndex
	)

private

Connects a variable node to given operand index of last created operation node.

Parameters

var	Variable to connect to operand of created operation node.
operandIndex	Index of operand to which variable is connected.

Exceptions

IllegalParameters Operand with requested index doesn't exist.

Definition at line 162 of file OperationDAGBuilder.cc.

                                                                       {
     
     // check if input or output
     Operation& currOp = currentOperation_->referencedOperation();        
     if (operandIndex > (unsigned)currOp.operandCount()) {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__,
             "Operation doesn't have operand number: " + 
             Conversion::toString(operandIndex));
     }
  
     if (currOp.operand(operandIndex).isInput()) {
         VariableBinding* srcNode = &getBinding(var);
         if (srcNode->first == NULL) {
             throw IllegalParameters(
                 __FILE__,__LINE__,__func__, 
                 TCEString("Source node: ") + Conversion::toString(operandIndex)
                 + " of operation " + currentOperation_->toString() 
                 + " is NULL. Maybe it is temp variable that has not been"
                 + " written yet? This happens in DAG of operation: " + operation_.name());
         }
             
         if (!dag_->hasNode(*srcNode->first)) {
             throw IllegalParameters(
                 __FILE__,__LINE__,__func__, 
                 TCEString("Source node: ") + Conversion::toString(operandIndex)
                 + " of operation " + currentOperation_->toString() 
                 + " not in dag. This happens in DAG of operation: " + operation_.name());
         }
                                     
         OperationDAGEdge* newEdge = 
             new OperationDAGEdge(srcNode->second, operandIndex);
         dag_->connectNodes(*srcNode->first, *currentOperation_, *newEdge);
         
     } else if (currOp.operand(operandIndex).isOutput()) {
         // set node, operandIndex pair for the variable
         VariableBinding varBind = 
             VariableBinding(currentOperation_, operandIndex);
         assignVariable(var, varBind);
         
     } else {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__,
             "Operation doesn't have operand number: " + 
             Conversion::toString(operandIndex));
     }
 }   

References __func__, assignVariable(), BoostGraph< GraphNode, GraphEdge >::connectNodes(), currentOperation_, dag_, getBinding(), BoostGraph< GraphNode, GraphEdge >::hasNode(), Operand::isInput(), Operand::isOutput(), OperationPimpl::name(), Operation::operand(), Operation::operandCount(), operation_, OperationNode::referencedOperation(), Conversion::toString(), and OperationNode::toString().

Referenced by parseNode().

Here is the call graph for this function:

◆ createOperationNode()

void OperationDAGBuilder::createOperationNode ( const std::string & operation )

private

Starts creation of new operation node.

Parameters

operation Name of operation which is referred by this node.

Exceptions

IllegalParameters Operation by requested name doesn't exist.

Definition at line 141 of file OperationDAGBuilder.cc.

                                                                    {
     OperationPool opPool;
     Operation& op = opPool.operation(operation.c_str());
   
     if (&op == &NullOperation::instance()) {
         throw IllegalParameters(__FILE__, __LINE__, __func__,
                                 "Operation: \"" + operation + "\" doesn't exist.");
     }        
     currentOperation_ = new OperationNode(op);
     dag_->addNode(*currentOperation_);        
 }

References __func__, BoostGraph< GraphNode, GraphEdge >::addNode(), currentOperation_, dag_, NullOperation::instance(), and OperationPool::operation().

Referenced by parseNode().

Here is the call graph for this function:

◆ declareVariable()

void OperationDAGBuilder::declareVariable ( const TokenizerData::TokenTreeNode * var )

private

Declared new variable which can be used for temporary storage of IO() variables.

Parameters

var	Token tree node containing variable name.

Exceptions

IllegalParameters If variable already exists.

Definition at line 270 of file OperationDAGBuilder.cc.

                                            {
     std::string varName = getVariableName(var);
     if (variableBindings_.find(varName) != variableBindings_.end()) {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__,
             "Variable \"" + var->token().stringValue() + 
             "\" already exists.");
     }
     variableBindings_[varName] = VariableBinding(NULL, 0);
 }

References __func__, getVariableName(), TokenizerData::Token::stringValue(), TokenizerData::TokenTreeNode::token(), and variableBindings_.

Referenced by parseNode().

Here is the call graph for this function:

◆ finalize()

void OperationDAGBuilder::finalize ( )

private

Finalizes DAG by creating output terminals.

TerminalNode objects are created for Those IO() operands, which are referred, but doesn't already have TerminalNode objects.

Definition at line 218 of file OperationDAGBuilder.cc.

                               {        
     // find IO(x) references, which doesn't has yet terminal
     unsigned int inputCount = operation_.numberOfInputs();
     unsigned int outputCount = operation_.numberOfOutputs();
  
     std::set<unsigned int> unwrittenOutputs;
     for (unsigned int i = 1; i <= outputCount; i++) {
         unwrittenOutputs.insert(i + inputCount);
     }
  
     for (std::map<std::string,TerminalBinding>::iterator iter = 
              ioVariables_.begin(); iter != ioVariables_.end(); iter++) {
  
         unwrittenOutputs.erase(iter->second.second);
         
         if (iter->second.first == NULL) {                
             VariableBinding& ioVar = getBinding(iter->second.second);
             if (iter->second.second > inputCount + outputCount) {
                 throw IllegalParameters(
                     __FILE__, __LINE__, __func__,
                     TCEString("Operation ") +  operation_.name() + 
                     TCEString(" doesn't have result operand number: ") +
                     Conversion::toString(iter->second.second));
             }
             iter->second.first = new TerminalNode(iter->second.second);
             dag_->addNode(*(iter->second.first));
             OperationDAGEdge* newEdge = 
                 new OperationDAGEdge(ioVar.second,1);
             dag_->connectNodes(
                 *(ioVar.first), *(iter->second.first), *newEdge);
         }
     }
     if (!unwrittenOutputs.empty()) {
         TCEString message = TCEString("DAG of operation: ") + 
             operation_.name() + " Does not write to output operand(s): ";
         while (!unwrittenOutputs.empty()) {
             message << Conversion::toString(*unwrittenOutputs.begin()) <<" ";
             unwrittenOutputs.erase(unwrittenOutputs.begin());
         }
         throw IllegalParameters(__FILE__,__LINE__,__func__, message);
     }
     // TODO: verify IO variable information of operation description
 }

References __func__, BoostGraph< GraphNode, GraphEdge >::addNode(), BoostGraph< GraphNode, GraphEdge >::connectNodes(), dag_, getBinding(), ioVariables_, OperationPimpl::name(), OperationPimpl::numberOfInputs(), OperationPimpl::numberOfOutputs(), operation_, and Conversion::toString().

Referenced by parse().

Here is the call graph for this function:

◆ getBinding() [1/3]

OperationDAGBuilder::VariableBinding & OperationDAGBuilder::getBinding ( const TokenizerData::TokenTreeNode * var )

private

Returns node and operand index of any existing variable, IO() call or constant.

Parameters

var	Funcion call or single identifier type of token tree node.

Returns: Node and operand index of any existing variable or IO() call.

Exceptions

IllegalParameter Parameter isn't function call or variable name.

Definition at line 363 of file OperationDAGBuilder.cc.

                                                                      {
     
     // check if variable is function IO(2) or normal var
     if (var->isFunctionCall()) {
         unsigned int srcOperand = getIOOperand(var);
         return getBinding(srcOperand);
         
     } else if (var->token().isIdentifier()) {
         std::string varName = getVariableName(var);
         return getBinding(varName);
         
     } else if (var->isInteger()) {
         return getConstantBinding(var->intValue());
  
     } else {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__, 
             "Parameter \"" + var->token().stringValue() + 
             "\" is not variable.");
     }
 }

References __func__, getConstantBinding(), getIOOperand(), getVariableName(), TokenizerData::TokenTreeNode::intValue(), TokenizerData::TokenTreeNode::isFunctionCall(), TokenizerData::Token::isIdentifier(), TokenizerData::TokenTreeNode::isInteger(), TokenizerData::Token::stringValue(), and TokenizerData::TokenTreeNode::token().

Referenced by assignVariable(), connectOperandToNode(), finalize(), and getBinding().

Here is the call graph for this function:

◆ getBinding() [2/3]

OperationDAGBuilder::VariableBinding & OperationDAGBuilder::getBinding ( std::string varName )

private

Returns node and operand index of any existing variable.

Parameters

varName Name of the variable whose current binding is requested.

Returns: Node and operand index where variable is currently assigned.

Exceptions

IllegalParameters Variable is not declared.

Definition at line 393 of file OperationDAGBuilder.cc.

                                                  {        
     if (variableBindings_.find(varName) ==  variableBindings_.end()) {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__, 
             "Trying to use uninitialized variable: " + varName);
     }
     return variableBindings_[varName];
 }

References __func__, and variableBindings_.

◆ getBinding() [3/3]

OperationDAGBuilder::VariableBinding & OperationDAGBuilder::getBinding ( unsigned int operandIndex )

private

Returns node and operand index of IO() variable.

If called first time creates TerminalNode and binds IO() to that node with operand index 1.

Parameters

operandIndex Number of IO whose current binding is requested.

Returns: Node and operand index where IO() is currently assigned.

Definition at line 430 of file OperationDAGBuilder.cc.

                                                          {        
     
     // if first reference, and its never set before, 
     // create startnode for variable and set 
     // outputbind to be 1
     
     // if variable name is used, it has to be created 
     // and initialized before
     std::string varName = 
         "IO(" + Conversion::toString(operandIndex) + ")";        
     
     if (variableBindings_.find(varName) == variableBindings_.end()) {
         TerminalNode* newNode = new TerminalNode(operandIndex);
         variableBindings_[varName] = VariableBinding(newNode, 1);
         dag_->addNode(*newNode);
         
         // mark terminal as created for check phase in finalize
         ioVariables_[varName] = TerminalBinding(newNode, operandIndex);
     }
     
     return getBinding(varName);
 }    

References BoostGraph< GraphNode, GraphEdge >::addNode(), dag_, getBinding(), ioVariables_, Conversion::toString(), and variableBindings_.

Here is the call graph for this function:

◆ getConstantBinding()

OperationDAGBuilder::VariableBinding & OperationDAGBuilder::getConstantBinding ( long value )

private

Returns node and operand index of any existing variable.

Parameters

varName Name of the variable whose current binding is requested.

Returns: Node and operand index where variable is currently assigned.

Exceptions

IllegalParameters Variable is not declared.

Definition at line 410 of file OperationDAGBuilder.cc.

                                                   {
     if (constantBindings_.find(value) ==  constantBindings_.end()) {
         ConstantNode* newNode = new ConstantNode(value);
         constantBindings_[value] = VariableBinding(newNode, 1);
         dag_->addNode(*newNode);
     }
  
     return constantBindings_[value];
 }

References BoostGraph< GraphNode, GraphEdge >::addNode(), constantBindings_, and dag_.

Referenced by getBinding().

Here is the call graph for this function:

◆ getIOOperand()

unsigned int OperationDAGBuilder::getIOOperand ( const TokenizerData::TokenTreeNode * var )

private

Returns operand's number of tree node, which contains reference to IO() variable.

Parameters

var	Token tree node, which contains parsed IO(x) call.

Returns: Operand number of IO(x) type of token tree node.

Exceptions

IllegalParameters If var isn't parsed IO() call.

Definition at line 462 of file OperationDAGBuilder.cc.

                                                                        {
     if (var->leafCount() != 2 || 
         var->leaf(0).token().stringValue() != "IO" ||  
         !var->leaf(1).leaf(0).token().isIntegerLiteral()) {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__, 
             "Invalid parameter node \"" + var->token().stringValue() + 
             "\" != \"IO(x)\" call.");
     }
     return var->leaf(1).leaf(0).token().intValue();
 }

References __func__, TokenizerData::Token::intValue(), TokenizerData::Token::isIntegerLiteral(), TokenizerData::TokenTreeNode::leaf(), TokenizerData::TokenTreeNode::leafCount(), TokenizerData::Token::stringValue(), and TokenizerData::TokenTreeNode::token().

Referenced by getBinding(), and getVariableName().

Here is the call graph for this function:

◆ getVariableName()

std::string OperationDAGBuilder::getVariableName ( const TokenizerData::TokenTreeNode * var )

private

Retuns name of variable, for token tree node containing IO() call or variable name.

Parameters

var	IO() call or variable name.

Returns: Generated variable name for internal variable map.

Exceptions

IllegalParameter Parameter is not variable..

Definition at line 327 of file OperationDAGBuilder.cc.

                                            {
     // check if variable is function IO(2) or normal var
     if (var->isFunctionCall()) {
         unsigned int srcOperand = getIOOperand(var);
         
         std::string retVal = 
             "IO(" + Conversion::toString(srcOperand) + ")";
         
         // mark terminal as referenced, but not created
         if (ioVariables_.find(retVal) == ioVariables_.end()) {
             ioVariables_[retVal] = TerminalBinding(NULL, srcOperand);
         }
         
         return retVal;
         
     } else if (var->token().isIdentifier()) {
         return var->token().stringValue();
         
     } else {
         throw IllegalParameters(
             __FILE__, __LINE__, __func__, 
             "Parameter \"" + var->token().stringValue() + 
             "\" is not variable.");
     }
 }

References __func__, getIOOperand(), ioVariables_, TokenizerData::TokenTreeNode::isFunctionCall(), TokenizerData::Token::isIdentifier(), TokenizerData::Token::stringValue(), TokenizerData::TokenTreeNode::token(), and Conversion::toString().

Referenced by assignVariable(), declareVariable(), and getBinding().

Here is the call graph for this function:

◆ parse()

void OperationDAGBuilder::parse ( )

Parses token tree presentation of OSAL DAG language to OperationDAG.

Definition at line 64 of file OperationDAGBuilder.cc.

                            {
     
     // Print out tokenized dag form...
     // std::cerr << rootNode_.toStr() << std::endl;
  
     // Loop through all leafs of root node and call finalization.        
     for (int i = 0; i < rootNode_.leafCount();i++) {
         const TokenizerData::TokenTreeNode* currNode = 
             &(rootNode_.leaf(i));
         parseNode(currNode);
     }        
     finalize();
 }

References finalize(), TokenizerData::TokenTreeNode::leaf(), TokenizerData::TokenTreeNode::leafCount(), parseNode(), and rootNode_.

Referenced by OperationDAGConverter::createDAG().

Here is the call graph for this function:

◆ parseNode()

void OperationDAGBuilder::parseNode ( const TokenizerData::TokenTreeNode * node )

private

Parses one token tree node to DAG representation.

Parameters

node	Node to parse.

Definition at line 84 of file OperationDAGBuilder.cc.

                                             {        
     
     switch(node->token().type_) {
     case TokenizerData::EXPRESSION_STATEMENT: {
         // ignore empty expressions
         if (node->leafCount() == 1)  {
             parseNode(&node->leaf(0));
         }
     } break;
     
     case TokenizerData::DECLARATION: {
         for (int i = 1; i < node->leafCount(); i++) {
             // TODO: check thata init declarator doesn't 
             //       doesnt't have leafs
             declareVariable(&node->leaf(i));
         }
     } break;
     
     case TokenizerData::ASSIGNMENT_EXPRESSION: {
         if (node->leafCount() == 1) {
             parseNode(&node->leaf(0));
             
         }  else if (node->isAssignment()) {               
             assignVariable(&node->leaf(0), &node->leaf(2));
             
         }  else if (node->isFunctionCall()) {
             // TODO: check if is execution macro                
             // get postfixpart
             node = &node->leaf(1);
             
             // leaf(0) create operation node
             createOperationNode(node->leaf(0).token().stringValue());
             
             // leaf(1)- ... connect nodes..
             for (int i = 1; i < node->leafCount(); i++) {
                 connectOperandToNode(&node->leaf(i), i);
             }
             
         } else {
             std::cerr << "Cannot parse: " << node->toStr();
         }
     } break;
     
     default:
         std::cerr << "Failed parsing: " << node->token().stringValue() 
                   << std::endl;
     }
 }

References TokenizerData::ASSIGNMENT_EXPRESSION, assignVariable(), connectOperandToNode(), createOperationNode(), TokenizerData::DECLARATION, declareVariable(), TokenizerData::EXPRESSION_STATEMENT, TokenizerData::TokenTreeNode::isAssignment(), TokenizerData::TokenTreeNode::isFunctionCall(), TokenizerData::TokenTreeNode::leaf(), TokenizerData::TokenTreeNode::leafCount(), TokenizerData::Token::stringValue(), TokenizerData::TokenTreeNode::token(), TokenizerData::TokenTreeNode::toStr(), and TokenizerData::Token::type_.

Referenced by parse().

Here is the call graph for this function:

Member Data Documentation

◆ constantBindings_

std::map<long, VariableBinding> OperationDAGBuilder::constantBindings_

private

Node representing constant value.

Definition at line 101 of file OperationDAGBuilder.hh.

Referenced by getConstantBinding().

◆ currentOperation_

OperationNode* OperationDAGBuilder::currentOperation_

private

Currently created handled operation.

Definition at line 95 of file OperationDAGBuilder.hh.

Referenced by connectOperandToNode(), and createOperationNode().

◆ dag_

OperationDAG* OperationDAGBuilder::dag_

private

DAG where all nodes and edges are added.

Definition at line 89 of file OperationDAGBuilder.hh.

Referenced by connectOperandToNode(), createOperationNode(), finalize(), getBinding(), and getConstantBinding().

◆ ioVariables_

std::map<std::string, TerminalBinding> OperationDAGBuilder::ioVariables_

private

IO(x) variables and corresponding TerminalNodes and operand indices.

Definition at line 104 of file OperationDAGBuilder.hh.

Referenced by assignVariable(), finalize(), getBinding(), and getVariableName().

◆ operation_

const OperationPimpl& OperationDAGBuilder::operation_

private

Definition at line 106 of file OperationDAGBuilder.hh.

Referenced by connectOperandToNode(), and finalize().

◆ rootNode_

const TokenizerData::TokenTreeNode& OperationDAGBuilder::rootNode_

private

Root of tokenized data parsed from OSAL DAG source code.

Definition at line 92 of file OperationDAGBuilder.hh.

Referenced by parse().

◆ variableBindings_

std::map<std::string, VariableBinding> OperationDAGBuilder::variableBindings_

private

Node and operand which are referred by IO(x) or declared variable.

Definition at line 98 of file OperationDAGBuilder.hh.

Referenced by assignVariable(), declareVariable(), and getBinding().

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ TerminalBinding

◆ VariableBinding

Constructor & Destructor Documentation

◆ OperationDAGBuilder()

Member Function Documentation

◆ assignVariable() [1/2]

◆ assignVariable() [2/2]

◆ connectOperandToNode()

◆ createOperationNode()

◆ declareVariable()

◆ finalize()

◆ getBinding() [1/3]

◆ getBinding() [2/3]

◆ getBinding() [3/3]

◆ getConstantBinding()

◆ getIOOperand()

◆ getVariableName()

◆ parse()

◆ parseNode()

Member Data Documentation

◆ constantBindings_

◆ currentOperation_

◆ dag_

◆ ioVariables_

◆ operation_

◆ rootNode_

◆ variableBindings_