Line data    Source code

       1              : #include "../../inc/lexicalAnalysis/tokenStream.h"
       2              : 
       3              : namespace nicole {
       4              : 
       5          135 : const std::expected<std::monostate, Error> TokenStream::eat() noexcept {
       6          135 :   if (currentPos_ < tokens_.size()) {
       7          126 :     ++currentPos_;
       8          126 :     return std::expected<std::monostate, Error>{std::monostate{}};
       9          126 :   }
      10            9 :   return createError(ERROR_TYPE::EAT, "invalid access to tokens while eating");
      11          135 : }
      12              : 
      13          144 : bool TokenStream::isEnd() const noexcept {
      14          144 :   return currentPos_ == tokens_.size();
      15          144 : }
      16              : 
      17           18 : const std::expected<Token, Error> TokenStream::current() const noexcept {
      18           18 :   if (currentPos_ < tokens_.size())
      19            9 :     return tokens_[currentPos_];
      20            9 :   return createError(ERROR_TYPE::CURRENT, "invalid access to tokens");
      21           18 : }
      22              : 
      23              : const std::expected<Token, Error>
      24           18 : TokenStream::lookAhead(const size_t pos) const noexcept {
      25           18 :   if (currentPos_ + pos < tokens_.size())
      26            9 :     return tokens_[currentPos_ + pos];
      27            9 :   return createError(ERROR_TYPE::LOOK_AHEAD, "invalid access to tokens");
      28           18 : }
      29              : 
      30            0 : const std::expected<Token, Error> TokenStream::lastRead() const noexcept {
      31            0 :   if (currentPos_ - 1 < tokens_.size())
      32            0 :     return tokens_[currentPos_ - 1];
      33            0 :   return createError(ERROR_TYPE::LAST_READ, "invalid access to tokens");
      34            0 : }
      35              : 
      36              : const std::expected<bool, Error>
      37           18 : TokenStream::isCurrentTokenType(const TokenType type) const noexcept {
      38           18 :   if (currentPos_ < tokens_.size())
      39            9 :     return tokens_[currentPos_].type() == type;
      40            9 :   return createError(ERROR_TYPE::IS_CURRENT_TOKEN_TYPE,
      41            9 :                      "invalid access to tokens");
      42           18 : }
      43              : 
      44              : bool TokenStream::isTokenAheadBeforeSemicolon(
      45           18 :     const TokenType type) const noexcept {
      46           18 :   bool foundToken{false};
      47           63 :   for (size_t i{currentPos_}; i < tokens_.size(); ++i) {
      48           63 :     auto tk{tokens_[i]};
      49           63 :     if (tk.type() == type) {
      50            9 :       foundToken = true;
      51            9 :       break;
      52            9 :     }
      53           54 :     if (tk.type() == TokenType::SEMICOLON) {
      54            9 :       break;
      55            9 :     }
      56           54 :   }
      57           18 :   return foundToken;
      58           18 : }
      59              : 
      60              : const std::expected<std::monostate, Error>
      61              : TokenStream::insertAfter(const TokenStream &tkStream,
      62           18 :                          const size_t pos) noexcept {
      63           18 :   if (pos == std::numeric_limits<int>::infinity()) {
      64            9 :     return createError(ERROR_TYPE::INSERT_AFTER,
      65            9 :                        "cannot insert after the given position");
      66            9 :   }
      67            9 :   tokens_.insert(tokens_.begin() + static_cast<long>(pos), tkStream.begin(),
      68            9 :                  tkStream.end());
      69            9 :   return std::expected<std::monostate, Error>{std::monostate{}};
      70           18 : }
      71              : 
      72            0 : void TokenStream::shiftToSemicolon() noexcept {
      73            0 :   while (currentPos_ < size()) {
      74            0 :     if (tokens_[currentPos_].type() == TokenType::SEMICOLON) {
      75            0 :       break;
      76            0 :     }
      77            0 :     ++currentPos_;
      78            0 :   }
      79            0 : }
      80              : 
      81              : } // namespace nicole