parser.h

Go to the documentation of this file.

#ifndef NEWLANG_PARSER_H_
#define NEWLANG_PARSER_H_
 
#include "dict.h"
#include "diag.h"
 
#include "warning_push.h"
 
#include "llvm/Support/Path.h"
#include "llvm/Support/FileSystem.h"
 
#include "parser.yy.h"
#include "warning_pop.h"
 
namespace newlang {
 
    TermPtr ProcessMacro(Parser &parser, TermPtr &term);
 
    enum class ExpandMacroResult : uint8_t {
        Continue,
        Break,
        Goto,
    };
    ExpandMacroResult ExpandTermMacro(Parser &parser);
 
    class Parser {
    public:
 
        Parser(MacroPtr macro = nullptr, PostLexerType *postlex = nullptr, DiagPtr diag = nullptr, bool pragma_enable = true, RunTime *rt = nullptr);
 
        virtual ~Parser() {
        }
        bool trace_scanning;
 
        bool trace_parsing;
 
        std::string m_filename;
        std::string m_name_module;
        parser::location_type m_location;
 
        struct ParserLocation {
            std::string filename;
            parser::location_type location;
        };
 
        std::vector<ParserLocation> m_loc_stack;
 
        std::istringstream m_stream;
 
 
        parser::token_type ExpandPredefMacro(TermPtr &term);
 
        static int m_counter;
        std::map<std::string, std::string> m_predef_macro;
        bool RegisterPredefMacro(const char * name, const char * desc);
        void InitPredefMacro();
        bool CheckPredefMacro(const TermPtr & term);
 
 
        // To demonstrate pure handling of parse errors, instead of
        // simply dumping them on the standard error output, we will pass
        // them to the driver using the following two member functions.
 
        void error(const class location& l, const std::string& m);
 
        void error(const std::string &m);
 
        class Scanner* lexer;
 
        void AstAddTerm(TermPtr &term);
        TermPtr GetAst();
 
        BlockType m_macro_analisys_buff; 
 
        TermPtr m_expected;
        TermPtr m_unexpected;
        TermPtr m_finalize;
        int m_finalize_counter;
        TermPtr m_annotation;
        bool m_no_macro;
        bool m_enable_pragma;
 
 
        parser::token_type GetNextToken(TermPtr * yylval, parser::location_type* yylloc);
        //        TermPtr MacroEval(const TermPtr &term);
 
        // Проверяет термин на наличие команды препроцессора (прагмы)
        bool PragmaCheck(const TermPtr &term);
        // Выполняет команду препроцессора (прагму)
        bool PragmaEval(const TermPtr &term, BlockType &buffer, BlockType &seq);
        bool PragmaStaticAssert(const TermPtr &term);
        static ObjPtr StaticEval(const TermPtr &term);
 
        TermPtr Parse(const std::string str, bool expand_module = false);
        TermPtr ParseFile(const std::string_view filename);
 
        // Собирает термин из последовательности лексем и удаялет их из входного буфера
        static size_t ParseTerm(TermPtr &term, const BlockType &buffer, const size_t skip = 0, bool pragma_enable = true);
        static TermPtr ParseTerm(const char *proto, MacroPtr macro = nullptr, bool pragma_enable = true);
 
        inline static bool IsBracket(const std::string_view str) {
            return str.size() > 0 && (str[0] == '(' || str[0] == '[' || str[0] == '<');
        }
 
 
        static std::string GetCurrentDate(time_t ts = std::time(NULL));
        static std::string GetCurrentTime(time_t ts = std::time(NULL));
        static std::string GetCurrentTimeStamp(time_t ts = std::time(NULL));
        static std::string GetCurrentTimeStampISO(time_t ts = std::time(NULL));
 
        TermPtr CheckModuleTerm(const TermPtr & term);
 
        static size_t SkipBrackets(const BlockType& buffer, size_t offset);
 
        time_t m_timestamp;
 
        std::string m_file_time;
        std::string m_file_md5;
 
        DiagPtr m_diag;
        MacroPtr m_macro;
        bool m_is_lexer_complete;
    private:
        TermPtr m_ast;
        bool m_is_runing;
        PostLexerType *m_postlex;
        RunTime *m_rt;
    };
 
    //    /*
    //     * 
    //     * 
    //     */
    //
    //    class FileParser : public Parser {
    //    public:
    //
    //        FileParser(MacroPtr macro = nullptr, PostLexerType *postlex = nullptr, DiagPtr diag = nullptr,
    //                bool pragma_enable = true, RunTime *rt = nullptr)
    //        : Parser(macro, postlex, diag, pragma_enable, rt) {
    //
    //            InitPredefMacro();
    //
    //            VERIFY(RegisterPredefMacro("@__FILE_MD5__", "MD5 hash for current file"));
    //            VERIFY(RegisterPredefMacro("@__FILE_TIMESTAMP__", "Timestamp current file"));
    //            VERIFY(RegisterPredefMacro("$\\\\", "Full name of the current module name"));
    //            VERIFY(RegisterPredefMacro("@\\\\", "Root directory with the main program module"));
    //
    //        }
    //
    //
    //        std::string m_file_time;
    //        std::string m_file_md5;
    //
    //        parser::token_type ExpandPredefMacro(TermPtr &term) override;
    //
    //        TermPtr CheckModuleTerm(const TermPtr & term) override;
    //        TermPtr ParseFile(const std::string_view filename);
    //    };
    //
 
} // namespace example
 
#endif // NEWLANG_PARSER_H_