stelaParser.hpp

이 파일의 문서화 페이지로 가기

 
#pragma once
 
#include "stela/ast.hpp"
#include "stela/parser/stelaTokenScanable.hpp"
#include "stela/parser/stelaTokenDispatcher.hpp"
#include "stela/parser/bison/stelaTokenScan.hpp"
#include "stela/parser/stelaSmartDedent.hpp"
 
namespace by {
    class stelaTokenScan;
 
    class _nout stelaParser: public stelaTokenScanable {
        BY(ME(stelaParser))
 
    public:
        stelaParser();
 
    public:
        tstr<stela> parse(const std::string& codes);
        tstr<stela> parse(const nchar* codes);
        tstr<stela> parseFromFile(const std::string& path);
        tstr<stela> parseFromFile(const nchar* path);
 
        stelaTokenDispatcher& getDispatcher();
        std::vector<ncnt>& getIndents();
 
        nbool isInit() const;
 
        template <typename T> void setScan() { _mode = &T::instance; }
 
        void rel();
 
        int pushState(int newState);
        int popState();
 
        // events:
        //  scan:
        using stelaTokenScanable::onScan;
        nint onScan(stelaParser& ps, ZZSTYPE* val, ZZLTYPE* loc, zzscan_t scanner, nbool& isBypass) override;
        nint onTokenEndOfFile();
        nint onTokenColon(nint tok);
        nint onTokenNewLine(nint tok);
        nint onTokenComma(nint tok);
        nint onIndent(ncnt col, nint tok);
        nint onDedent(ncnt col, nint tok);
        nint onIgnoreIndent(nint tok);
        nchar onScanUnexpected(const nchar* token);
 
        //  keyword:
        stela* onDefBlock(stela* stmt);
        stela* onDefBlock(stela* blk, stela* stmt);
        stela* onDefBlock();
 
        //  expr:
        //      def:
        //          var:
        template <typename T> stela* onPrimitive(const T& arg) { return new numStela(arg); }
 
        verStela* onVer(const std::string& version);
 
        stela* onDefProp(const std::string& name, stela& rhs);
        stela* onDefAssign(const std::string& name, stela* rhs);
        //          obj:
        stela* onDefOrigin(const std::string& name, stela& blk);
        //          container:
        stela* onDefArray();
        stela* onDefArray(stela& elem);
        stela* onDefArray(stela& as, stela& elem);
        //          file:
        stela* onCompilationUnit(stela* blk);
 
        void onParseErr(const std::string& msg, const nchar* symbolName);
        void report(const std::string& msg);
 
    private:
        void _prepare();
        void* _scanString(const nchar* src, void* scanner);
        nint _onTokenEndOfInlineBlock(nint tok);
        nint _onScan(ZZSTYPE* val, ZZLTYPE* loc, zzscan_t scanner);
        tstr<stela> _finalize();
        void _addElem(stela& arr, stela& elem);
        static std::string _idxName(ncnt n);
 
    private:
        stelaTokenScan* _mode;
        nbool _isIgnoreWhitespace;
        stelaTokenDispatcher _dispatcher;
        std::vector<ncnt> _indents;
        tstr<stela> _root;
        std::vector<nint> _states;
        stelaSmartDedent _dedent;
        std::vector<std::string> _errs;
 
    private:
        static constexpr ncnt IDX_WIDTH = 4;
    };
 
    template <> inline stela* stelaParser::onPrimitive(const nbool& arg) { return new boolStela(arg); }
 
    template <> inline stela* stelaParser::onPrimitive(const std::string& arg) { return new strStela(arg); }
} // namespace by