parser.hpp

Go to the documentation of this file.

#ifndef _PARSER_H__H
#define _PARSER_H__H
#include "ast.hpp"
#include "scanner/scanner.hpp"
#include "validator.hpp"
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace pascal {
    class ParseException : public std::runtime_error {
      public:
        explicit ParseException(const std::string &msg) : std::runtime_error(msg) {}
    };
} // namespace pascal
 
namespace mxx {
    class XParser {
      public:
        XParser() = delete;
        explicit XParser(const std::string &source)
            : scanner(source), token(nullptr), index(0) {
            scanner.scan();
            scanner.removeEOL();
            if (scanner.size() > 0) {
                token = &scanner[0];
                index = 0;
            }
        }

        bool next() {
            if (index + 1 < scanner.size()) {
                index++;
                token = &scanner[index];
                return true;
            }
            token = nullptr;
            return false;
        }

        bool peekIs(const std::string &s) {
            if (!token) return false;
            const auto &v = token->getTokenValue();
            if (v.size() != s.size()) return false;
            for (size_t i = 0; i < v.size(); ++i)
                if (std::tolower(static_cast<unsigned char>(v[i])) !=
                    std::tolower(static_cast<unsigned char>(s[i])))
                    return false;
            return true;
        }

        bool peekIs(const types::TokenType &t) {
            return token && token->getTokenType() == t;
        }

        static std::string tokenTypeToString(types::TokenType t) {
            switch (t) {
            case types::TokenType::TT_ID:
                return "IDENTIFIER";
            case types::TokenType::TT_NUM:
                return "NUMBER";
            case types::TokenType::TT_STR:
                return "STRING";
            case types::TokenType::TT_SYM:
                return "SYMBOL";
            default:
                return "UNKNOWN";
            }
        }
 
        std::string filename;  
 
      protected:
        scan::Scanner scanner;        
        scan::TToken *token = nullptr; 
        size_t index = 0;             
    };
} // namespace mxx
 
namespace pascal {
    class PascalParser : public mxx::XParser {
      public:
        PascalParser() = delete;
        explicit PascalParser(const std::string &source) : mxx::XParser(source), validator(source) {
            removeBraceComments();
            if (scanner.size() > 0) {
                token = &scanner[0];
                index = 0;
            } else {
                token = nullptr;
            }
        }

        std::unique_ptr<ProgramNode> parseProgram();
        std::unique_ptr<UnitNode> parseUnit();
        bool isUnitSource() const;
        mxx::TPValidator validator; 
 
      private:
        void removeBraceComments();
        void error(const std::string &message);
        void expectToken(const std::string &expected);
        void expectToken(types::TokenType expected);
        bool match(const std::string &s);
        bool match(types::TokenType t);
        std::unique_ptr<ASTNode> parseLValue();
        std::unique_ptr<BlockNode> parseBlock();
        std::unique_ptr<CompoundStmtNode> parseCompoundStatement();
        std::vector<std::unique_ptr<ASTNode>> parseDeclarations();
        std::unique_ptr<ASTNode> parseVarDeclaration();
        std::unique_ptr<ASTNode> parseConstDeclaration();
        std::unique_ptr<ASTNode> parseProcedureDeclaration();
        std::unique_ptr<ASTNode> parseFunctionDeclaration();
        std::vector<std::unique_ptr<ASTNode>> parseInterfaceDeclarations();
        std::unique_ptr<ASTNode> parseProcedureForwardDecl();
        std::unique_ptr<ASTNode> parseFunctionForwardDecl();
        std::vector<std::unique_ptr<ASTNode>> parseParameterList();
        std::vector<std::unique_ptr<ASTNode>> parseStatementList();
        std::unique_ptr<ASTNode> parseParameter();
        std::unique_ptr<ASTNode> parseRecordType();
        std::unique_ptr<ASTNode> parseTypeDeclaration();
        std::unique_ptr<ASTNode> parseStatement();
        std::unique_ptr<ASTNode> parseAssignmentOrProcCall();
        std::unique_ptr<ASTNode> parseIfStatement();
        std::unique_ptr<ASTNode> parseWhileStatement();
        std::unique_ptr<ASTNode> parseForStatement();
        std::unique_ptr<ASTNode> parseRepeatStatement();
        std::unique_ptr<ASTNode> parseCaseStatement();
        std::unique_ptr<ASTNode> parseWithStatement();
        std::unique_ptr<ASTNode> parseGotoStatement();
        void parseLabelDeclaration();
        std::unordered_set<std::string> declaredLabels;
        std::unique_ptr<ASTNode> parseExpression();
        std::unique_ptr<ASTNode> parseSimpleExpression();
        std::unique_ptr<ASTNode> parseTerm();
        std::unique_ptr<ASTNode> parseFactor();
        std::unique_ptr<ASTNode> parseProcedureCall(const std::string &name);
        std::unique_ptr<ASTNode> parseFunctionCall(const std::string &name);
        std::vector<std::unique_ptr<ASTNode>> parseArgumentList();

        bool isRelationalOperator();
        bool isAddOperator();
        bool isMulOperator();

        std::unique_ptr<ASTNode> parseTypeSpec();

        std::string getRelationalOp();
        std::string getAddOp();
        std::string getMulOp();
        std::string getUnaryOp();
        BinaryOpNode::OpType getComparisonOperator(const std::string &op);
        BinaryOpNode::OpType getLogicalOperator(const std::string &op);
        BinaryOpNode::OpType getArithmeticOperator(const std::string &op);
        std::string tokenTypeToString(types::TokenType type);
        bool isType(const std::string &token);
        bool isBuiltinProcedure(const std::string &name);
        bool isBuiltinFunction(const std::string &name);
        bool isKeyword(const std::string &s);
        std::unique_ptr<ASTNode> parseArrayType();
        std::unique_ptr<ASTNode> parseArrayDeclaration(const std::string &varName);
        bool isArrayAccess();
    };
} // namespace pascal
 
#endif