parser.hpp

Go to the documentation of this file.

#ifndef PARSER_HPP
#define PARSER_HPP

#include <memory>
#include "../globals.hpp"

#include "../util/ErrorReporter.hpp"
#include "../lexer/lexer.hpp"
#include "../ast/Program.hpp"
#include "../ast/ClassMember.hpp"
#include "../ast/ClassDeclaration.hpp"
#include "../ast/MainMethodDeclaration.hpp"
#include "../ast/FieldDeclaration.hpp"
#include "../ast/LVDStatement.hpp"
#include "../ast/Block.hpp"
#include "../ast/ExpressionStatement.hpp"
#include "../ast/Statement.hpp"
#include "../ast/IfStatement.hpp"
#include "../ast/WhileStatement.hpp"
#include "../ast/ReturnStatement.hpp"
#include "../ast/PostfixExpression.hpp"
#include "../ast/PostfixOp.hpp"
#include "../ast/ArrayAccess.hpp"
#include "../ast/FieldAccess.hpp"
#include "../ast/MethodInvocation.hpp"
#include "../ast/UnaryExpression.hpp"
#include "../ast/BinaryExpression.hpp"
#include "../ast/PrimaryExpression.hpp"
#include "../ast/Type.hpp"
#include "../ast/TypeIdent.hpp"

class Parser
{
    public:
        Parser(lexer::Lexer& lexer, shptr<ErrorReporter> errorReporter); // TODO: determine parameters

        bool start();
        shptr<ast::Program> getRoot();

    private:
        lexer::Lexer& lexer;
        shptr<ErrorReporter> errorReporter;
        shptr<ast::Program> astRoot;
        lexer::Token current;

        bool error_mode = false;
        bool errors_found = false;


        void nextToken();
        void expect(lexer::Token::Token_type const& tokenType);
        void expect(lexer::Token::Token_type const& tokenType, std::string const& string_val);

        void reportError(std::string const& error_msg);

        /*
         * Precedences of all operators, associativity is stored implicitly
         */
        int operator_precs(lexer::Token::Token_type t);

        shptr<ast::Program> parseProgram();
        shptr<vec<shptr<ast::ClassMember>>> parseClassMembers();
        shptr<ast::MainMethodDeclaration> parseMainMethod();

        shptr<ast::TypeIdent> parseTypeIdent();
        shptr<ast::Type> parseType();
        shptr<ast::Type> parseBasicType();
        int parseArrayDecl();
        shptr<ast::Expression> parseNewArrayExpression();
        int parseOptionalBrackets();

        shptr<ast::ClassMember> parseFieldOrMethod();
        shptr<vec<shptr<ast::TypeIdent>>> parseOptionalParameters();
        shptr<ast::Arguments> parseArguments();

        shptr<ast::stmt::Statement> parseStatement();
        shptr<ast::stmt::Block> parseBlock();
        shptr<ast::stmt::Statement> parseBlockStatement();
        shptr<ast::stmt::LVDStatement> parseLocalVariableDeclarationStatement();
        shptr<ast::stmt::IfStatement> parseIfStatement();
        shptr<ast::stmt::WhileStatement> parseWhileStatement();
        shptr<ast::stmt::ReturnStatement> parseReturnStatement(source_position_t position);

        shptr<ast::Expression> parseExpression();
        shptr<ast::Expression> precedenceClimb(int minPrec);
        shptr<ast::Expression> parseUnaryExpression();

        shptr<ast::Expression> parsePrimaryExpression();
        shptr<vec<shptr<ast::po::PostfixOp>>> parsePostfixOps();
        shptr<ast::po::PostfixOp> parseMethodInvocationOrFieldAccess();

        shptr<ast::Expression> parseNewObjectExpression();
        shptr<ast::Expression> parseNewObjectOrNewArrayExpression();

};

#endif