ll1parsing.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_PARSING_LL1PARSING_H
#define ELEMENTA_PARSING_LL1PARSING_H
 
 
#include <deque>
#include "elementa/parsing/parsing.h"
 
namespace elementa
{
 
namespace parsing
{
 
/* **********************************************************************
 
    Class: LL1Parser
 
*************************************************************************/
 
 
class LL1Parser final: public Parser
{
 public:
 
 
    LL1Parser(const CFGrammar & gr, 
              const CFGrammar::LL1Table & table,
              Lexer & lexer, 
              const TransfTokenId & transftid = [](Token &)->void{}):
                                                    Parser{gr,lexer,transftid}, 
                                                    table_{table}
        { reset(); }
 
 
    ~LL1Parser(void) = default; 
 
 
    Parser::Result parseStep(Parser::Observer & obs);
 
    void reset(void);
    void printStatus(elementa::base::OutSerCh & chout) const;
 
 private:
 
    class StackItem
    {
     public:
 
        using Deque = std::deque<StackItem>;
 
        bool endofrule_or_elem; 
        union Data
        {
            CFGrammar::RuleIterator endofrule;
            CFGrammar::CodeElement elem;
 
            Data(const CFGrammar::RuleIterator & ri): endofrule{ri} {}
            Data(const CFGrammar::CodeElement ce): elem{ce} {}
            ~Data(void) {}
            // copies and moves deleted
        } data;
 
        StackItem(const CFGrammar::RuleIterator & ri):  
                                                    endofrule_or_elem{true},
                                                    data{ri} {}
        StackItem(const CFGrammar::CodeElement ce): 
                                                    endofrule_or_elem{false},
                                                    data{ce} {}
 
        ~StackItem(void) {}
        // copies and moves deleted - use emplace_back to push values into deque
 
        std::string to_string(const CFGrammar & gr) const
        { return(std::string{"StackItem "} + 
                 (endofrule_or_elem ? "rule marker" : "grammar element") +
                 (endofrule_or_elem ? (": [" + gr.to_string(*data.endofrule) +
                                       "]") :
                                      (": code " + std::to_string(data.elem) +
                                       " '" + (gr.isTerminal(data.elem,true) ? 
                                                gr.nameOfTerminal(data.elem) :
                                                gr.nameOfNonTerminal(data.elem))
                                       + "'"))); }
    };
 
    const CFGrammar::LL1Table & table_;
    StackItem::Deque stack_;
    bool thereislookahead_;
    Token::Ptr lookahead_;
    elementa::base::SerChLoc::Ptr lookaheadloc_;
 
    const CFGrammar::RuleIterator & lastRuleInStack(void) const;
    void updateLookahead(void);
    Parser::Result unrollStack(Parser::Observer & obs);
 
};
 
 // LL1 Parsing
 
} // End parsing namespace
 
} // End elementa namespace 
 
 
#endif