Branch data     Line data    Source code

       1                 :            : #pragma once
       2                 :            : 
       3                 :            : 
       4                 :            : #include "lex/Lexer.hpp"
       5                 :            : #include <array>
       6                 :            : #include <mutable/lex/Token.hpp>
       7                 :            : #include <mutable/lex/TokenType.hpp>
       8                 :            : #include <mutable/parse/AST.hpp>
       9                 :            : #include <mutable/util/Diagnostic.hpp>
      10                 :            : 
      11                 :            : 
      12                 :            : namespace m {
      13                 :            : 
      14                 :            : namespace ast {
      15                 :            : 
      16                 :            : struct M_EXPORT Parser
      17                 :            : {
      18                 :            :     using follow_set_t = std::array<bool, unsigned(TokenType::TokenType_MAX) + 1>;
      19                 :            : 
      20                 :            :     public:
      21                 :            :     Lexer      &lexer;
      22                 :            :     Diagnostic &diag;
      23                 :            : 
      24                 :            :     private:
      25                 :            :     std::array<Token, 2> lookahead_;
      26                 :            : 
      27                 :            :     public:
      28                 :       2008 :     explicit Parser(Lexer &lexer)
      29                 :       2008 :         : lexer(lexer)
      30                 :       2008 :         , diag(lexer.diag)
      31   [ +  -  +  - ]:       2008 :         , lookahead_({Token::CreateArtificial(), Token::CreateArtificial()})
      32                 :            :     {
      33         [ +  - ]:       2008 :         consume();
      34         [ +  - ]:       2008 :         consume();
      35                 :       2008 :     }
      36                 :            : 
      37                 :            :     template<unsigned Idx = 0>
      38                 :      94891 :     const Token & token() { return lookahead_[Idx]; }
      39                 :            : 
      40                 :         21 :     bool is(const TokenType tt) { return token() == tt; }
      41                 :          2 :     bool no(const TokenType tt) { return token() != tt; }
      42                 :            : 
      43                 :      26921 :     Token consume() {
      44                 :      26921 :         auto old = token();
      45         [ +  + ]:      53842 :         for (std::size_t i = 1; i != lookahead_.size(); ++i)
      46         [ +  - ]:      26921 :             lookahead_[i - 1] = lookahead_[i];
      47   [ +  -  +  - ]:      26921 :         lookahead_.back() = lexer.next();
      48                 :      26921 :         return old;
      49         [ +  - ]:      26921 :     }
      50                 :            : 
      51                 :      21649 :     bool accept(const TokenType tt) {
      52   [ +  +  +  + ]:      21649 :         if (token() == tt or token() == TK_ERROR) {
      53                 :      16011 :             consume();
      54                 :      16011 :             return true;
      55                 :            :         }
      56                 :       5638 :         return false;
      57                 :      21649 :     }
      58                 :            : 
      59                 :      12864 :     bool expect(const TokenType tt) {
      60         [ +  + ]:      12864 :         if (accept(tt)) return true;
      61                 :        194 :         diag.e(token().pos) << "expected " << tt << ", got " << token().text << '\n';
      62                 :        194 :         return false;
      63                 :      12864 :     }
      64                 :            : 
      65                 :            :     /** Consumes tokens until the first occurence of a token in the follow set \p FS is found. */
      66   [ +  +  +  + ]:        521 :     void recover(const follow_set_t &FS) { while (token() and not FS[token().type]) consume(); }
      67                 :            : 
      68                 :            :     /** Consumes tokens until the first occurence of a token in the follow set \p FS is found. Constructs an object of
      69                 :            :      * type `T` on \p start and returns a unique pointer to it.  Here, type `T` is either `ErrorStmt` or `ErrorClause`.
      70                 :            :      */
      71                 :            :     template<typename T>
      72                 :        154 :     std::unique_ptr<T> recover(Token start, const follow_set_t &FS) {
      73                 :        154 :         recover(FS);
      74                 :        154 :         return std::make_unique<T>(std::move(start));
      75                 :            :     }
      76                 :            : 
      77                 :            :     std::unique_ptr<Command> parse();
      78                 :            :     std::unique_ptr<Instruction> parse_Instruction();
      79                 :            :     std::unique_ptr<Stmt> parse_Stmt();
      80                 :            : 
      81                 :            :     /* Statements */
      82                 :            :     std::unique_ptr<Stmt> parse_CreateDatabaseStmt();
      83                 :            :     std::unique_ptr<Stmt> parse_DropDatabaseStmt();
      84                 :            :     std::unique_ptr<Stmt> parse_UseDatabaseStmt();
      85                 :            :     std::unique_ptr<Stmt> parse_CreateTableStmt();
      86                 :            :     std::unique_ptr<Stmt> parse_DropTableStmt();
      87                 :            :     std::unique_ptr<Stmt> parse_CreateIndexStmt();
      88                 :            :     std::unique_ptr<Stmt> parse_DropIndexStmt();
      89                 :            :     std::unique_ptr<Stmt> parse_SelectStmt();
      90                 :            :     std::unique_ptr<Stmt> parse_InsertStmt();
      91                 :            :     std::unique_ptr<Stmt> parse_UpdateStmt();
      92                 :            :     std::unique_ptr<Stmt> parse_DeleteStmt();
      93                 :            :     std::unique_ptr<Stmt> parse_ImportStmt();
      94                 :            : 
      95                 :            :     /* Clauses */
      96                 :            :     std::unique_ptr<Clause> parse_SelectClause();
      97                 :            :     std::unique_ptr<Clause> parse_FromClause();
      98                 :            :     std::unique_ptr<Clause> parse_WhereClause();
      99                 :            :     std::unique_ptr<Clause> parse_GroupByClause();
     100                 :            :     std::unique_ptr<Clause> parse_HavingClause();
     101                 :            :     std::unique_ptr<Clause> parse_OrderByClause();
     102                 :            :     std::unique_ptr<Clause> parse_LimitClause();
     103                 :            : 
     104                 :            :     /* Expressions */
     105                 :            :     std::unique_ptr<Expr> parse_Expr(int precedence_lhs = 0, std::unique_ptr<Expr> lhs = nullptr);
     106                 :            :     std::unique_ptr<Expr> parse_designator();
     107                 :            :     std::unique_ptr<Expr> expect_integer();
     108                 :            : 
     109                 :            :     /* Types */
     110                 :            :     const Type * parse_data_type();
     111                 :            : };
     112                 :            : 
     113                 :            : }
     114                 :            : 
     115                 :            : }