#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.

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

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) {}

TokenizerData::TokenTreeNode::data_

Token * data_

Token of token tree node.

Definition OperationDAGLanguageParser.hh:607

Referenced by addToTokenTree().

◆ TokenTreeNode() [2/2]

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

inline

Definition at line 400 of file OperationDAGLanguageParser.hh.

400: data_(&token) {}

TokenizerData::TokenTreeNode::token

const Token & token() const

Definition OperationDAGLanguageParser.hh:494

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));
        }

References addToTokenTree(), token(), and TokenTreeNode().

Referenced by TokenizerData::addToken(), addToTokenTree(), and addToTokenTree().

Here is the call graph for this function:

◆ 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 addToTokenTree(), data_, TokenizerData::Token::end_, leafs_, and TokenizerData::Token::start_.

Here is the call graph for this function:

◆ 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, TokenizerData::Token::intValue(), isInteger(), leaf(), leafCount(), and token().

Referenced by OperationDAGBuilder::getBinding().

Here is the call graph for this function:

◆ 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;
        }

References TokenizerData::ASSIGNMENT_OPERATOR, leaf(), leafCount(), and token().

Referenced by OperationDAGBuilder::parseNode().

Here is the call graph for this function:

◆ 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;
        }

References leaf(), leafCount(), TokenizerData::POSTFIX_EXPRESSION, TokenizerData::PRIMARY_EXPRESSION, and token().

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

Here is the call graph for this function:

◆ 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;
        }

References leaf(), leafCount(), and token().

Referenced by OperationDAGBuilder::getBinding(), and intValue().

Here is the call graph for this function:

◆ 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, leafCount(), and leafs_.

Referenced by OperationDAGBuilder::getIOOperand(), intValue(), isAssignment(), isFunctionCall(), isInteger(), OperationDAGBuilder::parse(), OperationDAGBuilder::parseNode(), and toStr().

Here is the call graph for this function:

◆ 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();
        }

References leafs_.

Referenced by OperationDAGBuilder::getIOOperand(), intValue(), isAssignment(), isFunctionCall(), isInteger(), leaf(), OperationDAGBuilder::parse(), OperationDAGBuilder::parseNode(), and toStr().

◆ 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_;
        }

References data_.

Referenced by addToTokenTree(), OperationDAGBuilder::assignVariable(), OperationDAGBuilder::declareVariable(), OperationDAGBuilder::getBinding(), OperationDAGBuilder::getIOOperand(), OperationDAGBuilder::getVariableName(), intValue(), isAssignment(), isFunctionCall(), isInteger(), 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();
        }