xbexp.h

Go to the documentation of this file.

/*  xbexp.h
 
XBase64 Software Library
 
Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
 
The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
Email Contact:
 
    XDB-devel@lists.sourceforge.net
    XDB-users@lists.sourceforge.net
 
*/
 
 
#ifndef __XB_EXP_H__
#define __XB_EXP_H__
 
 
// #ifdef  CMAKE_COMPILER_IS_GNUCC
// #pragma interface
// #endif
 
 
 
#ifdef XB_FUNCTION_SUPPORT
#define XB_EXP_CHAR      'C'
#define XB_EXP_DATE      'D'
#define XB_EXP_LOGICAL   'L'
#define XB_EXP_NUMERIC   'N'
#define XB_EXP_UNKNOWN   'U'
#endif
 
#ifdef XB_EXPRESSION_SUPPORT
 
#define XB_EXP_CONSTANT      'C'
#define XB_EXP_FUNCTION      'F'
#define XB_EXP_FIELD         'D'
#define XB_EXP_OPERATOR      'O'
#define XB_EXP_NOTROOT       'N'    // not root node, needs further parsing
#define XB_EXP_PRE_OPERATOR  'B'    // (B)efore) pre increment, pre decrement
#define XB_EXP_POST_OPERATOR 'A'    // (A)fter)  post increment, pre decrement
 
#define XB_END_OF_EXPRESSION -100
 
// #define XB_UNBALANCED_PARENS -101
// #define XB_UNBALANCED_QUOTES -102
 
 
namespace xb{
 
struct XBDLLEXPORT xbExpToken {
  xbString sExpression;      // in - expression to pull next token from
                             // out - remainder of the expression after token removed
  xbString sToken;           // next token pulled from the expression
  char     cNodeType;        // one of XB_EXP_CONSTANT, XB_EXP_FUNCTION, XB_EXP_FIELD, XB_EXP_OPERATOR, XB_EXP_NOTROOT
  char     cReturnType;      // one of XB_EXP_CHAR, XB_EXP_DATE, XB_EXP_LOGICAL, XB_EXP_NUMERIC, XB_EXP_UNKNOWN
  xbInt16  iSts;             // return status after retrieving or attempting next token from expression
                             // 0 = no error
                             // XB_END_OF_EXPRESSION
                             // XB_UNBALANCED_PARENS
                             // XB_UNBALANCED_QUOTES
  char     cPrevNodeType;    // previous node type
  char     cPrevReturnType;  // previous return type
 
  // constructor
  xbExpToken() { cNodeType = 0; cReturnType = 0; iSts = 0; cPrevNodeType = 0; cPrevReturnType = 0; }
};
 
 
/************************************************************************/
 
 
class XBDLLEXPORT xbExp{
 
  public:
    xbExp( xbXBase * );
    xbExp( xbXBase *, xbDbf * );
    virtual ~xbExp();
    void ClearTreeHandle();
 
 
    #ifdef XB_DEBUG_SUPPORT
    void      DumpTree( xbInt16 iOption );
    void      DumpToken( xbExpToken &t, xbInt16 iOption = 0 );
    #endif
 
    xbInt16   GetResultLen() const;
    char      GetReturnType() const;
    xbInt16   GetBoolResult( xbBool &bResult );
    xbInt16   GetDateResult( xbDate &dtResult );
    xbInt16   GetNumericResult( xbDouble &dResult );
    xbInt16   GetStringResult( xbString &sResult );
    xbInt16   GetStringResult( char * vpResult, xbUInt32 ulLen );
    xbExpNode *GetTreeHandle();
    xbInt16   ParseExpression( const xbString &sExpression );
    xbInt16   ParseExpression( xbDbf *dbf, const xbString &sExpression );
    xbInt16   ProcessExpression();
    xbInt16   ProcessExpression( xbInt16 iRecBufSw );
 
 
  protected:
    xbInt16   GetNextToken( xbExpToken &t );
    xbInt16   OperatorWeight( const xbString &sOperator );
    xbExpNode *GetNextNode( xbExpNode * n ) const;  // traverses the tree from bottom left node, right, then up
 
  private:    // methods
 
    // xbInt16 CalcExpressionResultLen();
    xbInt16 CalcFunctionResultLen( xbExpNode *n ) const;
    xbInt16 CalcCharNodeLen( xbExpNode *n );
    xbInt16 CheckParensAndQuotes( const xbString &sExpression );
    xbInt16 GetExpressionResultLen() const;
 
    xbInt16 GetTokenCharConstant   ( xbExpToken &t );
    xbInt16 GetTokenDatabaseField  ( xbExpToken &t );
    xbInt16 GetTokenDateConstant   ( xbExpToken &t );
    xbInt16 GetTokenFunction       ( xbExpToken &t );
    xbInt16 GetTokenLogicalConstant( xbExpToken &t );
    xbInt16 GetTokenNumericConstant( xbExpToken &t );
    xbInt16 GetTokenOperator       ( xbExpToken &t );
    xbInt16 GetTokenParen          ( xbExpToken &t );
 
    xbBool  IsFunction             ( const xbString &sExp, char &cReturnType );
    xbBool  IsLogicalConstant      ( const xbString &sExp );
    xbBool  IsNumericConstant      ( const xbString &sExp, char cPrevNodeType );
    xbBool  IsOperator             ( const xbString &sExp );
    char    IsTokenSeparator       ( char c );
    xbBool  IsWhiteSpace           ( char c );
 
    xbInt16 ParseExpression        ( const xbString &sExpression, xbInt16 iWeight );
    xbInt16 ParseExpressionConstant( xbExpToken &t, xbExpNode *n );
    xbInt16 ParseExpressionFunction( xbExpToken &t, xbExpNode *n, xbInt16 iWeight );
    xbInt16 ParseExpressionFunctionParms( const xbString &sParms, xbLinkList<xbString> &llParms );
    xbInt16 ParseExpressionField   ( xbExpToken &t, xbExpNode *n );
    xbInt16 ParseExpressionOperator( xbExpToken &t, xbExpNode *n, xbInt16 iWeight );
 
    xbInt16 ProcessExpressionFunction( xbExpNode *n, xbInt16 iRecBufSw = 0 );
    xbInt16 ProcessExpressionOperator( xbExpNode *n );
 
  private:   // fields
    xbXBase   *xbase;
    xbDbf     *dbf;
    xbExpNode *nTree;        // pointer to tree of expNodes
    // xbInt16   iExpLen;       // size of expression result
 
 
};
 
/* Expression handler */
 
 
};
#endif        // XB_EXPRESSION_SUPPORT
#endif        // __XB_EXP_H__