token.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
#ifndef __token_hpp__
#define __token_hpp__
 
 
#include "bTypes.hpp"
 
 
 
namespace pFlow
{
 
class token;
class iIstream;
class iOstream;
 
iOstream& operator<<(iOstream& os, const token& tok);
 
 
class token
{
public:
 
    enum tokenType
    {
        UNDEFINED = 0,    
 
        // Fundamental types
        FLAG,             
        PUNCTUATION,      
        BOOL,             
        INT64,            
        FLOAT,            
        DOUBLE,           
 
        // Pointer types
        WORD,             
        STRING,           
        DIRECTIVE,        
        VARIABLE,         
 
        ERROR,            
    };
 
 
    enum flagType
    {
        NO_FLAG = 0,   
        ASCII   = 1,   
        BINARY  = 2    
    };
 
 
    enum punctuationToken : char
    {
        NULL_TOKEN     = '\0',  
        SPACE          = ' ',   
        TAB            = '\t',  
        NL             = '\n',  
 
        END_STATEMENT  = ';',   
        BEGIN_LIST     = '(',   
        END_LIST       = ')',   
        BEGIN_SQR      = '[',   
        END_SQR        = ']',   
        BEGIN_BLOCK    = '{',   
        END_BLOCK      = '}',   
        COLON          = ':',   
        COMMA          = ',',   
        DOLLAR         = '$',   
        SQUOTE         = '\'',  
        DQUOTE         = '"',   
 
        SUBTRACT       = '-',   
        DIVIDE         = '/',   
 
        BEGIN_STRING   = DQUOTE, 
        END_STRING     = DQUOTE  
    };
 
    static const inline token undefinedToken();
 
    static token endList()
    {
        return token(punctuationToken::END_LIST);
    }
 
    static token beginList()
    {
        return token(punctuationToken::BEGIN_LIST);
    }
 
    static token endStatement()
    {
        return token(punctuationToken::END_STATEMENT);
    }
 
    static token beginBlock()
    {
        return token(punctuationToken::BEGIN_BLOCK);
    }
 
    static token endBlocK()
    {
        return token(punctuationToken::END_BLOCK);
    }
 
    static token beginSquare()
    {
        return token(punctuationToken::BEGIN_SQR);
    }
 
    static token endSquare()
    {
        return token(punctuationToken::END_SQR);
    }
 
    static token space()
    {
        return token(punctuationToken::SPACE);
    }
 
    static token newLine()
    {
        return token(punctuationToken::NL);
    }
 
private:
 
    union content
    {
        // Fundamental values. Largest first for any {} initialization.
        int64_t int64Val;
 
        int flagVal;   // bitmask - stored as int, not enum
        punctuationToken punctuationVal;
        float floatVal;
        double doubleVal;
 
        // Pointers
        word* wordPtr;
        word* stringPtr;
    };
 
 
 
    //  For memory alignment this should appear as the first member.
    content data_;
 
    tokenType type_;
 
    int32 lineNumber_;
 
 
    // Private Member Functions
 
    inline void setUndefined();
 
    void parseError(const char* expected) const;
 
 
public:
 
 
 
        inline constexpr token() noexcept;
 
        inline token(const token& t);
 
        inline token(token&& t);
 
        inline explicit token(punctuationToken p, int32 lineNumber=0);
 
        inline explicit token(const uint64 val, int32 lineNumber=0);
 
        inline explicit token(const uint32 val, int32 lineNumber=0);
 
        inline explicit token(const uint8 val, int32 lineNumber=0);
 
        inline explicit token(const int64 val, int32 lineNumber=0);
 
        inline explicit token(const int32 val, int32 lineNumber=0);
 
        inline explicit token(const int8 val, int32 lineNumber=0);
 
        inline explicit token(const float val, int32 lineNumber=0);
 
        inline explicit token(const double val, int32 lineNumber=0);
 
        inline explicit token(const word& w, int32 lineNumber=0, bool isString = false);
 
 
        inline explicit token(word&& w, int32 lineNumber=0, bool isString = false);
 
        explicit token(iIstream& is);
 
 
        inline ~token();
 
 
 
        inline static token boolean(bool on);
 
        inline static token flag(int bitmask);
 
        inline static bool isseparator(int c);
 
 
 
    // - Status
 
        word name() const;
 
        inline tokenType type() const;
 
        inline bool setType(const tokenType tokType);
 
        inline int32 lineNumber() const;
 
        inline int32& lineNumber();
 
        inline bool good() const;
 
        inline bool undefined() const;
 
        inline bool error() const;
 
        inline bool isBool() const;
 
        inline bool isFlag() const;
 
        inline bool isPunctuation() const;
 
        inline bool isSeparator() const;
 
        inline bool isEndStatement() const;
 
        inline bool isEndBlock()const;
 
        inline bool isInt64() const;
 
        inline bool isInt32() const;
 
        inline bool isFloat() const;
 
        inline bool isDouble() const;
 
        inline bool isReal() const;
 
        inline bool isNumber() const;
 
        inline bool isWord() const;
 
        inline bool isDirective() const;
 
        inline bool isString() const;
 
        inline bool isVariable() const;
 
        inline bool isStringType() const;
 
 
    //- Access
 
        inline bool boolToken() const;
 
        inline int flagToken() const;
 
        inline punctuationToken pToken() const;
 
        //  Report FatalIOError and return \b 0 if token is not INT64
        inline int64 int64Token() const;
 
        inline int32 int32Token() const;
 
        inline float floatToken() const;
 
        inline double doubleToken() const;
 
        inline real realToken() const;
 
        inline real number() const;
 
        inline const word& wordToken() const;
 
        inline const word& stringToken() const;
 
 
    //- Edit
 
        inline void reset();
 
        inline void setBad();
 
        inline void swap(token& tok);
 
 
    //- Assignment
 
        inline void operator=(const token& tok);
 
        inline void operator=(token&& tok);
 
        inline void operator=(const punctuationToken p);
 
        inline void operator=(const int64 val);
 
        inline void operator=(const int32 val);
 
        inline void operator=(const float val);
 
        inline void operator=(const double val);
 
        inline void operator=(const word& w);
 
                
 
        inline void operator=(word&& w);
 
        
    //- Equality
 
        inline bool operator==(const token& tok) const;
        inline bool operator==(const punctuationToken p) const;
        inline bool operator==(const int64 val) const;
        inline bool operator==(const int32 val) const;
        inline bool operator==(const float val) const;
        inline bool operator==(const double val) const;
        inline bool operator==(const word& w) const;
 
 
    //- Inequality
 
        inline bool operator!=(const token& tok) const;
        inline bool operator!=(const punctuationToken p) const;
        inline bool operator!=(const int64 val) const;
        inline bool operator!=(const int32 val) const;
        inline bool operator!=(const float val) const;
        inline bool operator!=(const double val) const;
        inline bool operator!=(const word& w) const;
 
        iOstream& printInfo(iOstream& os)const;
 
        std::ostream& printInfo(std::ostream& os)const;
    
    //- IOstream Operators
 
        friend iOstream& operator<<(iOstream& os, const token& tok);
        friend iOstream& operator<<(iOstream& os, const punctuationToken& pt);
 
        // mostly used for debuging and developement 
        friend std::ostream& operator<<(std::ostream& os, const token& tok);
        friend std::ostream& operator<<(std::ostream& os, const punctuationToken& pt); 
        
        void operator=(word*) = delete;
 
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
// IOstream Operators
 
iIstream& operator>>(iIstream& is, token& tok);
iOstream& operator<<(iOstream& os, const token::punctuationToken& pt);
std::ostream&  operator<<(std::ostream& os, const token::punctuationToken& pt);
std::ostream& operator<<(std::ostream& os, const token& tok);
 
 
inline token endListToken()
{
    return token::endList();
}
 
inline token beginListToken()
{
    return token::beginList();
}
 
inline token endStatementToken()
{
    return token::endStatement();
}
 
inline token beginBlockToken()
{
    return token::beginBlock();
}
 
inline token endBlocKToken()
{
    return token::endBlocK();
}
 
inline token spaceToken()
{
    return token::space();
}
 
inline token newLineToken()
{
    return token::newLine();
}
 
 
} // End namespace pFlow
 
 
#include "tokenI.hpp"
 
 
#endif