WAST::StaticData Struct Reference

Collaboration diagram for WAST::StaticData:

Public Member Functions
	StaticData ()

Public Attributes
NFA::Machine	nfaMachine

Detailed Description

Definition at line 27 of file Lexer.cpp.

Constructor & Destructor Documentation

StaticData()

WAST::StaticData::StaticData

(

)

Definition at line 65 of file Lexer.cpp.

    {
        static const std::pair<TokenType,const char*> regexpTokenPairs[] =
        {
            {t_decimalInt,"[+\\-]?\\d+(_\\d+)*"},
            {t_decimalFloat,"[+\\-]?\\d+(_\\d+)*\\.(\\d+(_\\d+)*)*([eE][+\\-]?\\d+(_\\d+)*)?"},
            {t_decimalFloat,"[+\\-]?\\d+(_\\d+)*[eE][+\\-]?\\d+(_\\d+)*"},
 
            {t_hexInt,"[+\\-]?0[xX][\\da-fA-F]+(_[\\da-fA-F]+)*"},
            {t_hexFloat,"[+\\-]?0[xX][\\da-fA-F]+(_[\\da-fA-F]+)*\\.([\\da-fA-F]+(_[\\da-fA-F]+)*)*([pP][+\\-]?\\d+(_\\d+)*)?"},
            {t_hexFloat,"[+\\-]?0[xX][\\da-fA-F]+(_[\\da-fA-F]+)*[pP][+\\-]?\\d+(_\\d+)*"},
 
            {t_floatNaN,"[+\\-]?nan(:0[xX][\\da-fA-F]+(_[\\da-fA-F]+)*)?"},
            {t_floatInf,"[+\\-]?inf"},
 
            {t_string,"\"([^\"\n\\\\]*(\\\\([^0-9a-fA-Fu]|[0-9a-fA-F][0-9a-fA-F]|u\\{[0-9a-fA-F]+})))*\""},
 
            {t_name,"\\$[a-zA-Z0-9\'_+*/~=<>!?@#$%&|:`.\\-\\^\\\\]+"},
        };
 
        static const std::tuple<TokenType,const char*,bool> literalTokenTuples[] =
        {
            std::make_tuple(t_leftParenthesis,"(",true),
            std::make_tuple(t_rightParenthesis,")",true),
            std::make_tuple(t_equals,"=",true),
 
            #define VISIT_TOKEN(name,description) std::make_tuple(t_##name,#name,false),
            ENUM_LITERAL_TOKENS()
            #undef VISIT_TOKEN
 
            #undef VISIT_OPERATOR_TOKEN
            #define VISIT_OPERATOR_TOKEN(_,name,nameString,...) std::make_tuple(t_##name,nameString,false),
            ENUM_OPERATORS(VISIT_OPERATOR_TOKEN)
            #undef VISIT_OPERATOR_TOKEN
        };
    
        Timing::Timer timer;
 
        NFA::Builder* nfaBuilder = NFA::createBuilder();
        
        for(auto regexpTokenPair : regexpTokenPairs)
        {
            NFA::StateIndex finalState = NFA::maximumTerminalStateIndex - (NFA::StateIndex)regexpTokenPair.first;
            finalState = createTokenSeparatorPeekState(nfaBuilder,finalState);
            Regexp::addToNFA(regexpTokenPair.second,nfaBuilder,0,finalState);
        }
        
        for(auto literalTokenTuple : literalTokenTuples)
        {
            const TokenType tokenType = std::get<0>(literalTokenTuple);
            const char* literalString = std::get<1>(literalTokenTuple);
            const bool isTokenSeparator = std::get<2>(literalTokenTuple);
 
            NFA::StateIndex finalState = NFA::maximumTerminalStateIndex - (NFA::StateIndex)tokenType;
            if(!isTokenSeparator) { finalState = createTokenSeparatorPeekState(nfaBuilder,finalState); }
 
            addLiteralToNFA(literalString,nfaBuilder,0,finalState);
        }
 
        #ifndef _DEBUG
        if(false)
        #endif
        {
            std::ofstream debugGraphStream("nfaGraph.dot");
            debugGraphStream << NFA::dumpNFAGraphViz(nfaBuilder).c_str();
            debugGraphStream.close();
        }
 
        nfaMachine = NFA::Machine(nfaBuilder);
 
        #ifndef _DEBUG
        if(false)
        #endif
        {
            std::ofstream debugGraphStream("dfaGraph.dot");
            debugGraphStream << nfaMachine.dumpDFAGraphViz().c_str();
            debugGraphStream.close();
        }
 
        Timing::logTimer("built lexer tables",timer);
    }

Here is the call graph for this function:

Member Data Documentation

nfaMachine

NFA::Machine WAST::StaticData::nfaMachine

Definition at line 29 of file Lexer.cpp.

---

The documentation for this struct was generated from the following file:

• libraries/wasm-jit/Source/WAST/Lexer.cpp