#include <OperationDAGLanguageParser.hh>

Collaboration diagram for TokenizerData::TokenTreeNode:

Public Member Functions
	TokenTreeNode ()

	TokenTreeNode (Token &token)

bool	isFunctionCall () const

bool	isAssignment () const

bool	isInteger () const

long	intValue () const

void	addToTokenTree (Token &token)

const Token &	token () const

int	leafCount () const

TokenTreeNode &	leaf (int index) const

std::string	toStr () const

Static Private Member Functions
static void	addToTokenTree (TokenTreeNode currNode, TokenTreeNode newToken)

Private Attributes
Token *	data_
	Token of token tree node. More...

std::vector< TokenTreeNode * >	leafs_
	Leafs of this node. More...

Detailed Description

One node of tree of tokens.

Each node contains reference to it's token and it's sub-token-nodes..

root \ function / \ name postfix / | name name

Definition at line 397 of file OperationDAGLanguageParser.hh.

Constructor & Destructor Documentation

◆ TokenTreeNode() [1/2]

TokenizerData::TokenTreeNode::TokenTreeNode ( )

inline

Definition at line 399 of file OperationDAGLanguageParser.hh.

399 : data_(NULL) {}

◆ TokenTreeNode() [2/2]

TokenizerData::TokenTreeNode::TokenTreeNode ( Token & token )

inline

Definition at line 400 of file OperationDAGLanguageParser.hh.

400 : data_(&token) {}

Member Function Documentation

◆ addToTokenTree() [1/2]

void TokenizerData::TokenTreeNode::addToTokenTree ( Token & token )

inline

Adds newly parsed token to tree under this token tree node.

Parameters

token Token to add token tree.

Definition at line 485 of file OperationDAGLanguageParser.hh.

                                           {
             addToTokenTree(this, new TokenTreeNode(token));
         }

◆ addToTokenTree() [2/2]

static void TokenizerData::TokenTreeNode::addToTokenTree	(	TokenTreeNode *	currNode,
		TokenTreeNode *	newToken
	)

inlinestaticprivate

Adds token tree node to under other token tree node.

Parameters

currNode	Node where to add new node.
newToken	Token tree node to add to currNode.

Definition at line 561 of file OperationDAGLanguageParser.hh.

                                                               {
             
             // check if token should be part of one of the leafs
             for (std::vector<TokenTreeNode*>::iterator i = 
                      currNode->leafs_.begin() ;    
                  i != currNode->leafs_.end();i++) {
                 TokenTreeNode *currLeaf = *i;
                 
                 // if this token should be part of current leaf
                 if (newToken->data_->start_ >= currLeaf->data_->start_ &&
                     newToken->data_->end_ <= currLeaf->data_->end_) {
                     
                     addToTokenTree(currLeaf, newToken);
                     return;
                 }
                 
                 // move current leafs to inside this token
                 // if necessary
                 if (newToken->data_->start_ <= currLeaf->data_->start_ && 
                     newToken->data_->end_ >= currLeaf->data_->end_) {
                     
                     // remove from original 
                     std::vector<TokenTreeNode*>::iterator temp = i;
                     i--;
                     currNode->leafs_.erase(temp);
                     
                     // add to new...
                     newToken->leafs_.push_back(currLeaf);
                 }
                 
                 // if start of current leaf is after end of this.. 
                 // add token to this point.
                 if (newToken->data_->end_ <= currLeaf->data_->start_) {
                     currNode->leafs_.insert(i, newToken);
                     return;
                 }                
             }       
             
             // if there wasn't any sub nodes where value could go, add it to
             // end of current node 
             currNode->leafs_.push_back(newToken);
             return;        
         }

References data_, TokenizerData::Token::end_, leafs_, and TokenizerData::Token::start_.

◆ intValue()

long TokenizerData::TokenTreeNode::intValue ( ) const

inline

Definition at line 460 of file OperationDAGLanguageParser.hh.

                               {
             if (!isInteger()) {
                 // TODO: throw exception
                 assert(false && "Node is not integer.");
             }                        
  
             long retVal = 0;
  
             if (leafCount() == 2) {
                 retVal = leaf(1).token().intValue();
                 if (leaf(0).token().isMinusOperator()) {
                     retVal = -retVal;
                 }
             } else {
                 retVal = token().intValue();
             }
  
             return retVal;
         }

References assert.

Referenced by OperationDAGBuilder::getBinding().

◆ isAssignment()

bool TokenizerData::TokenTreeNode::isAssignment ( ) const

inline

Returns true if node contain tokens of assignment

leafs must be: ANY, ASSIGNMENT_OPERATOR, ANY

Returns: true if node is assginment.

Definition at line 427 of file OperationDAGLanguageParser.hh.

                                   {
             if (leafCount() == 3 && 
                 leaf(1).token().type_ == ASSIGNMENT_OPERATOR) {
                 return true;
             }            
             return false;
         }

Referenced by OperationDAGBuilder::parseNode().

◆ isFunctionCall()

bool TokenizerData::TokenTreeNode::isFunctionCall ( ) const

inline

Returns true if node contain tokens of function call.

leafs must be: PRIMARY_EXPRESSION, POSTFIX_EXPRESSION

Returns: true if node is function call.

Definition at line 410 of file OperationDAGLanguageParser.hh.

                                     {
             if (leafCount() == 2 && 
                 leaf(0).token().type_ == PRIMARY_EXPRESSION &&
                 leaf(1).token().type_ == POSTFIX_EXPRESSION) {
                 return true;
             }
             return false;
         }

Referenced by OperationDAGBuilder::getBinding(), OperationDAGBuilder::getVariableName(), and OperationDAGBuilder::parseNode().

◆ isInteger()

bool TokenizerData::TokenTreeNode::isInteger ( ) const

inline

Returns true if node contain integer value.

leafs must be: none, or (+|-, isIntegerLiteral)

Returns: true if node is integer value.

Definition at line 442 of file OperationDAGLanguageParser.hh.

                                {
             if (
                 // if two part integer e.g. -1 or +1 
                 (leafCount() == 2 && 
                  leaf(1).token().isIntegerLiteral() &&                  
                  (leaf(0).token().isPlusOperator() || 
                   leaf(0).token().isMinusOperator())) ||
                 
                 // or if just number without prefix
                 (leafCount() == 0 && token().isIntegerLiteral()) 
                 ) {
                 
                 return true;
             }
  
             return false;
         }

Referenced by OperationDAGBuilder::getBinding().

◆ leaf()

TokenTreeNode& TokenizerData::TokenTreeNode::leaf ( int index ) const

inline

Returns leaf of requested index.

Parameters

index Index of leaf to return.

Returns: leaf of requested index.

Definition at line 513 of file OperationDAGLanguageParser.hh.

                                              {
             assert(index < leafCount());
             return *leafs_[index];
         }

References assert.

Referenced by OperationDAGBuilder::getIOOperand(), OperationDAGBuilder::parse(), and OperationDAGBuilder::parseNode().

◆ leafCount()

int TokenizerData::TokenTreeNode::leafCount ( ) const

inline

Returns number of leafs that this token tree node has.

Returns: Number of leafs that this token tree node has.

Definition at line 503 of file OperationDAGLanguageParser.hh.

                               {
             return leafs_.size();
         }

Referenced by OperationDAGBuilder::getIOOperand(), OperationDAGBuilder::parse(), and OperationDAGBuilder::parseNode().

◆ token()

const Token& TokenizerData::TokenTreeNode::token ( ) const

inline

Returns referred token of token tree node.

Returns: Referred token of token tree node.

Definition at line 494 of file OperationDAGLanguageParser.hh.

                                    {
             return *data_;
         }

Referenced by OperationDAGBuilder::assignVariable(), OperationDAGBuilder::declareVariable(), OperationDAGBuilder::getBinding(), OperationDAGBuilder::getIOOperand(), OperationDAGBuilder::getVariableName(), and OperationDAGBuilder::parseNode().

◆ toStr()

std::string TokenizerData::TokenTreeNode::toStr ( ) const

inline

Returns node and its sub nodes as a string.

Returns: Node and its sub nodes as a string.

Definition at line 524 of file OperationDAGLanguageParser.hh.

                                 {
             static int recursioLevel = 0;
             
             recursioLevel++;
             std::stringstream retVal;            
             
             if (data_ == NULL) {
                 retVal << "Root node" << std::endl;
             } else {
                 retVal << setw(5) << data_->start_ << ":" 
                        << setw(5) << std::left << data_->end_ << std::right 
                        << setw(30) << TokenizerData::idString(data_->type_) 
                        << " ";
                 
                 for (int fill = 0; fill < (recursioLevel-2)*2; fill++) {
                     retVal << "*";
                 } 
                 
                 retVal << " " << data_->strValue_ << std::endl;
             }
             
             for (int i = 0; i < leafCount(); i++) { 
                 retVal << " " << leaf(i).toStr();
             }
             
             recursioLevel--;
             return retVal.str();
         }