Example #1
0
/*!
*/
xbShort xbExpn::ReduceComplexExpression(const char *NextToken, xbShort Len,
              xbExpNode *cn, xbDbf *d) {
  const char *p;
  xbShort rc;
  xbExpNode * SaveTree;

  SaveTree = Tree;
  Tree = NULL;

  p = NextToken;
  p++;

  if(( rc = BuildExpressionTree( p, Len-2, d )) != XB_NO_ERROR )
    return rc;

  if(cn->Node) {  /* then this is the base tree */
    cn->Node->Sibling2 = Tree;
    Tree->Node = cn->Node;
    delete cn;
    Tree = SaveTree;
  } else
    delete cn;

  return XB_NO_ERROR;
}
Example #2
0
/*!
*/
xbShort xbExpn::ProcessExpression(const char *e, xbDbf *d) {
  xbShort rc;
  if(( rc = BuildExpressionTree( e, strlen( e ), d )) != XB_NO_ERROR )
    return rc;
  if(( rc = ProcessExpression( Tree )) != XB_NO_ERROR )
    return rc;
  return XB_NO_ERROR;
}
Example #3
0
/*!
*/
xbShort xbExpn::ReduceFunction(const char *NextToken, xbExpNode *cn, xbDbf *d)
{
  const char *p;
  xbShort rc;
  xbShort FuncTokenLen;
  xbExpNode * SaveTree;

  p = strchr( NextToken, '(' );
  if (!p)
    return XB_PARSE_ERROR;

  p++;
  while( IsWhiteSpace( *p )) p++;
  if (*p == ')')
    return XB_NO_ERROR;

  /* do function paramater 1 */
  FuncTokenLen = GetFunctionTokenLen( p );
  SaveTree = Tree;
  Tree = NULL;
  if(( rc = BuildExpressionTree( p, FuncTokenLen, d )) != XB_NO_ERROR )
    return rc;
  cn->Sibling1 = Tree;
  Tree->Node = cn;
  Tree = SaveTree;

  /* do function paramater 2 */

  p += FuncTokenLen;
  while( IsWhiteSpace( *p )) p++;
  if(*p == ')')
    return XB_NO_ERROR;
  if( *p != ',' )
    return XB_PARSE_ERROR;

  p++;
  while( IsWhiteSpace( *p )) p++;
  FuncTokenLen = GetFunctionTokenLen( p );
  SaveTree = Tree;
  Tree = NULL;
  if(( rc = BuildExpressionTree( p, FuncTokenLen, d )) != XB_NO_ERROR )
    return rc;

  cn->Sibling2 = Tree;
  Tree->Node = cn;
  Tree = SaveTree;

  /* do function paramater 3 */
  p += FuncTokenLen;
  while( IsWhiteSpace( *p )) p++;
  if (*p == ')')
    return XB_NO_ERROR;
  if( *p != ',' )
    return XB_PARSE_ERROR;

  p++; 
  while( IsWhiteSpace( *p )) p++;
  FuncTokenLen = GetFunctionTokenLen( p );
  SaveTree = Tree;
  Tree = NULL;
  if(( rc = BuildExpressionTree( p, FuncTokenLen, d )) != XB_NO_ERROR )
    return rc;

  cn->Sibling3 = Tree;
  Tree->Node = cn;
  Tree = SaveTree;

  return XB_NO_ERROR;
}
Example #4
0
/*!
*/
xbShort xbExpn::ParseExpression(const char *exp, xbDbf *d) {
   return BuildExpressionTree(exp, strlen(exp), d);
}
Example #5
0
bool ExpressionTree::SetInfixExpression(const char* inFix)
{       
    cout << "Infix:" << inFix << "\n";        
    vector<ItemTokenInfo>().swap(vecPostfixResult);
    //vecPostfixResult.shrink_to_fit();
                        
    CTokenParser parser;
    parser.PutExpression((char*)inFix);

    stack<ItemTokenInfo> opStack;
    string postFixString = "";    
    bool bErrorOccurred = false;

    while (1)
    {
        ItemTokenInfo token;
        memset(&token, 0x00, sizeof(token));
        if (!parser.GetToken(&token))
        {
            bErrorOccurred = true;
            break;
        }

        if (0 == token.nLength)
        {
            break;
        }

        #ifdef _DEBUG_MORE_
        cout << __LINE__ << ": token.nLength=" << token.nLength  << " token.nType=" << token.nType
             << " token.strTokenValue= " << token.strValue  <<  "\n";
        #endif
        
        if (IsUserFunction(&token))
        {
            opStack.push(token); //no precedence between functions 
        }
        else if (IsOperand(&token))
        {
            postFixString += " ";
            postFixString += token.strValue;
            vecPostfixResult.push_back(token);            
        }
        else if (IsOperator(&token))
        {
            while ( !opStack.empty() &&
                     LEFT_PARENTHESIS != opStack.top().nDetailedType && 
                     GetOperatorPrecedence(&opStack.top(), &token) <= 0 
                  )
            {                
                postFixString += " ";
                postFixString += opStack.top().strValue;
                vecPostfixResult.push_back(opStack.top());
                opStack.pop();                
            }
            opStack.push(token);            
        }
        else if (COMMA == token.nDetailedType && token.bThisTokenBelongsToTheUserFunctions ) // SumInt(1+1, 2)
        {
            while (!opStack.empty() &&
                    LEFT_PARENTHESIS != opStack.top().nDetailedType                     
                  )
            {
                postFixString += " ";
                postFixString += opStack.top().strValue;
                vecPostfixResult.push_back(opStack.top());
                opStack.pop();
            }           
        }
        else if (LEFT_PARENTHESIS == token.nDetailedType)
        {            
            opStack.push(token);
        }
        else if (RIGHT_PARENTHESIS == token.nDetailedType) 
        {
            //pop till starting '('
            while (!opStack.empty())
            {                
                if (LEFT_PARENTHESIS == opStack.top().nDetailedType)
                {
                    if (token.bThisTokenBelongsToTheUserFunctions)
                    {
                        //pop till starting function name 
                        opStack.pop(); 
                        
                        if (opStack.top().nDetailedType == LEFT_PARENTHESIS)
                        {
                            // (SumInt(1,1))
                            opStack.pop();
                        }
                        else
                        {
                            postFixString += " ";
                            postFixString += opStack.top().strValue; //function name
                            vecPostfixResult.push_back(opStack.top());
                            opStack.pop();
                        }
                        
                        break; 
                    }
                    else
                    {
                        opStack.pop();                         
                        break; 
                    }                    
                }
                postFixString += " ";
                postFixString += opStack.top().strValue;
                vecPostfixResult.push_back(opStack.top());
                                
                opStack.pop();
            }
        } //RIGHT_PARENTHESIS
    }

    if (bErrorOccurred)
    {
        return false;
    }

    while (!opStack.empty())
    {
        postFixString += " ";
        postFixString += opStack.top().strValue;

        vecPostfixResult.push_back(opStack.top());

        opStack.pop();        
    }

    cout << "Postfix is: " << postFixString << endl;
    
    return BuildExpressionTree();    
}