fsms.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_ADTS_FSM_H
#define ELEMENTA_ADTS_FSM_H
 
/*
#define ELE_PRE_TRACED
#include "elementa/base/debugging.h"
*/
 
#include <memory>
#include <type_traits>
#include <cstring>
#include <string>
#include <vector>
#include <list>
#include <utility>
#include <locale>
#include "elementa/base/definitions.h"
#include "elementa/base/exceptions.h"
 
 
namespace elementa
{
 
namespace adts
{
 
/* ***************************************************************************
 
    Virtual base class: BaseFSM
    
*******************************************************************************/
 
 
class BaseFSM
{
 public:
 
    using Num = size_t;
 
    virtual ~BaseFSM(void) = default;
 
 
    virtual bool atEnd(void) const = 0;
 
 
    virtual void reset(void) = 0;
 
 
    void resetCheck(void)
        { reset(); 
          if (atEnd()) ELE_CODE_INVSTATE("FSM [" + to_string() + 
                                        "] at ending state right after reset, "
                                        "before consuming anything"); }
 
    virtual std::string to_string(void) const
    {
        return(std::string{"FSM ("} + 
               std::to_string(elementa::base::to_number(this)) +
               "). atEnd: " + elementa::base::kYesNoCString(atEnd())); }
 
};
 
 
/* ***************************************************************************
 
    Template virtual base class: FSM
    Alias: BaseTextFSM
    
*******************************************************************************/
 
 
template <typename Obs = char>
class FSM: public BaseFSM
{
 public:
 
    using Ptr = std::shared_ptr<FSM>;
 
 
 
    virtual bool consume(Obs o) = 0; 
 
 private:
 
static_assert(std::is_scalar<Obs>::value, "Obs must be a scalar type in a FSM");
};
 
 
class BaseTextFSM: public FSM<>
{
 public:
 
 
    BaseTextFSM(bool casesensitive = true): casesensitive_{casesensitive} {}
 
 
 protected:
 
    char caseChar(char c) 
        { return(casesensitive_ ? c : std::toupper(c,std::locale())); }
 
    bool casesensitive_;
};
 
 
/* ===========================================================================
 
        SOME COMMON FSMS
 
============================================================================= */
 
/* ***************************************************************************
 
    Class: CharFSM
    
*******************************************************************************/
 
class CharFSM: public BaseTextFSM
{
 public:
 
 
    CharFSM(char c):c_{c} { reset(); }
 
    void reset(void) { end_ = false; }
    bool atEnd(void) const { return(end_); }
 
    bool consume(char o) 
        { if (o == c_) { end_ = true; return(true); } else return(false); }
 
    char character(void) const noexcept { return(c_); }
 
    std::string to_string(void) const
        { return("Char" + BaseTextFSM::to_string()); }
 
 
 private:
 
    char c_;
    bool end_;
};
 
 
/* ***************************************************************************
 
    Class: SeparatorsFSM
    
*******************************************************************************/
 
 
class SeparatorsFSM: public BaseTextFSM
{
 public:
 
 
    SeparatorsFSM(const std::string & seps = "\n\t \f\r\v\x00"):seps_{seps} 
        { reset(); }
 
    void reset(void) { end_ = false; }
    bool atEnd(void) const { return(end_); }
 
    bool consume(char o) 
        { if (seps_.find_first_of(o) != std::string::npos)
            { end_ = true; return(true); }
          else return(false); }
 
    const std::string & separators(void) const noexcept
        { return(seps_); }
 
    std::string to_string(void) const
        { return("Separators" + BaseTextFSM::to_string()); }
 
 
 private:
 
    const std::string seps_;
    bool end_;
};
 
 
/* ***************************************************************************
 
    Class: IdentifierFSM
    
*******************************************************************************/
 
 
class IdentifierFSM: public BaseTextFSM
{
 public:
 
    IdentifierFSM(void) { reset(); }
 
    bool atEnd(void) const { return(end_); }
    bool consume(char o);
    void reset(void) { init_ = true; end_ = false; }
 
    std::string to_string(void) const
        { return("Identifier" + BaseTextFSM::to_string()); }
 
 
 private:
 
    bool init_,end_;
 
    static constexpr bool kIsDigit(char c)
        { return((c >= '0')&&(c <= '9')); }
 
    static constexpr bool kIsCharOfIdentifier(char c)
        { return( (c=='_') ||
                ( (c>='a') && (c<='z') ) ||
                ( (c>='A') && (c<='Z') ) ); }
 
};
 
 
/* ***************************************************************************
 
    Class: KeywordFSM
    
*******************************************************************************/
 
 
class KeywordFSM: public BaseTextFSM
{
 public:
 
 
    KeywordFSM(const std::string & word, bool casesens = true);
 
    KeywordFSM(const KeywordFSM & o):word_{nullptr} { copyFrom(o); }
    KeywordFSM & operator=(const KeywordFSM & o)
        { copyFrom(o); return(*this); }
    KeywordFSM(KeywordFSM && o) = delete;
    KeywordFSM & operator=(KeywordFSM && o) = delete;
 
    ~KeywordFSM(void) { delete [] word_; }
 
    std::string word(void) const { return(rdstr()); }
 
    bool atEnd(void) const { return(rdpos() >= rdlen()); }
    bool consume(char o) 
        {  if ((rdpos() >= rdlen()) || 
               (caseChar(o) != caseChar(rd()))) return(false);
           inc(); return(true); }
    void reset(void) { wrpos(0); }
 
    std::string to_string(void) const
        { return("Keyword[" + word() + "]" + BaseTextFSM::to_string()); }
 
 private:
 
    char * word_; // stores position, length and string
 
    void copyFrom(const KeywordFSM & o);
    size_t rdlen(void) const 
        { return(static_cast<size_t>(static_cast<uint8_t>(word_[1]))); }
    uint8_t rdpos(void) const { return(static_cast<uint8_t>(word_[0])); }
    void wrlen(size_t l) { word_[1] = static_cast<char>(l); }
    void wrpos(uint8_t p) { word_[0] = static_cast<char>(p); }
    void inc(void) { ++word_[0]; }
    void wrstr(const std::string & s) 
        { if (!s.empty()) std::memcpy(word_+2,s.c_str(),s.size()); }
    std::string rdstr(void) const 
        { return(rdlen() == 0 ? std::string{} : std::string{word_+2,rdlen()}); }
    char rd(void) const { return(word_[rdpos()+2]); }
};
 
 
/* ***************************************************************************
 
    Class: CommentsFSM
    
*******************************************************************************/
 
 
class CommentsFSM: public BaseTextFSM
{
 public:
 
 
    CommentsFSM(const std::string & commstart = "/*",
                const std::string & commend = "*/");
 
    CommentsFSM(const CommentsFSM &) = delete;
    CommentsFSM(CommentsFSM &&) = delete;
    CommentsFSM & operator=(const CommentsFSM &) = delete;
    CommentsFSM & operator=(CommentsFSM &&) = delete;
 
    ~CommentsFSM(void) { delete cstart_; delete cend_; }
 
    void reset(void) { st_ = State::kInit; cstart_->reset(); cend_->reset(); }
    bool atEnd(void) const { return(st_ == State::kFinished); }
 
    bool consume(char o);
 
    std::string beginText(void) const
        { return(cstart_->word()); }
 
    std::string endText(void) const
        { return(cend_->word()); }
 
    std::string to_string(void) const
        { return("Comments" + BaseTextFSM::to_string()); }
 
 
 private:
 
    enum State { kInit, kStart, kBody, kEnd, kFinished };
 
    State st_;
    KeywordFSM * cstart_, * cend_;
};
 
 
/* ***************************************************************************
 
    Class: IntegerTextFSM
    
*******************************************************************************/
 
 
class IntegerTextFSM: public BaseTextFSM
{
 public:
 
    ELE_CLASS_ENUM(Kind,
                    kDec,   // no preffix
                    kHex,   // '0x' preffix
                    kOct,   // '0' preffix
                    kBin);  // '0b' preffix
 
 
    IntegerTextFSM(Kind kind = Kind::kDec,
                   bool withsign = true):kind_{kind},withsign_{withsign}
        { reset(); }
 
    IntegerTextFSM(const IntegerTextFSM & o) { copyFrom(o); }
    IntegerTextFSM(IntegerTextFSM && o) { copyFrom(o); }
    IntegerTextFSM & operator=(const IntegerTextFSM & o)
        { copyFrom(o); return(*this); }
    IntegerTextFSM & operator=(IntegerTextFSM && o) 
        { copyFrom(o); return(*this); }     
 
    bool atEnd(void) const { return(atend_); }
    bool consume(char o);
    void reset(void);
 
    std::string to_string(void) const
        { return("IntegerText[" + KindEnum::IdName(kind_) + 
                 (withsign_ ? ", with sign" : "") + "]" + 
                 BaseTextFSM::to_string()); }
 
 private:
 
    enum :uint8_t { kStInit, kAfterSign };
 
    Kind kind_;
    bool withsign_,alreadysign_;    
    size_t len_;
    uint8_t st_;
    bool atend_;
 
    void copyFrom(const IntegerTextFSM & o);
    bool recognizeAfterSign(char c);
};
 
 
/* ***************************************************************************
 
    Class: NumberTextFSM
    
*******************************************************************************/
 
 
class NumberTextFSM: public BaseTextFSM
{
 public:
 
    NumberTextFSM(void) { reset(); }
 
    NumberTextFSM(const NumberTextFSM & o) { copyFrom(o); }
    NumberTextFSM(NumberTextFSM && o) { copyFrom(o); }
    NumberTextFSM & operator=(const NumberTextFSM & o)
        { copyFrom(o); return(*this); }
    NumberTextFSM & operator=(NumberTextFSM && o) 
        { copyFrom(o); return(*this); }     
 
    bool atEnd(void) const { return(atend_); }
    bool consume(char o);
    void reset(void);
 
    std::string to_string(void) const
        { return("NumberText" + BaseTextFSM::to_string()); }
 
 private:
 
    enum :uint8_t { kStInit, kStMantissa, kStMantissaDigit, 
                             kStExponentInit, kStExponent };
 
    uint8_t st_;
    bool alreadysign_,alreadydot_;
    bool atend_;
 
    void copyFrom(const NumberTextFSM & o);
};
 
 
 // FSM
 
 
} // end adts namespace
 
} // end elementa namespace
 
 
#endif