[语法分析]LR语法分析器的构造

最新推荐文章于 2024-12-24 14:43:54 发布
最新推荐文章于 2024-12-24 14:43:54 发布 · 1.7k 阅读 · 1
文章标签：

#360 #F#

本文深入解析LR分析器的工作原理，包括consumeNonTerminal和consumeToken函数的实现细节，以及如何通过Goto表和预测分析表进行状态转移和错误处理。文章还提供了LR分析器的构造过程及其核心组件的代码示例。

    LR分析器的consumeNonTerminal函数在上一节提到过，其实跟Goto表没有关系：如果在分析器内部规约得到一个非终结符，那么规约函数执行结束之后，马上就会根据传入宏的“leftPart”在Goto表中查找对应的目标状态并压栈，而根本不用执行consumeNonTerminal函数。这个成员函数的用武之地在于接受其它分析器得到的非终结符，并在Goto表中“额外”的那一列里查找对应状态并压栈//

#define wrapname(name) name ## _LRAnalyser

static void wrapname(consumeNonTerminal)(void* self,
                                         struct AbstractSyntaxNode* nonTerminal)
{
    struct LRAnalyser* lra = (struct LRAnalyser*)self;
    struct LRState* currentState = (struct LRState*)
                                   (lra->stateStack->peek(lra->stateStack));
    lra->symbolStack->push(lra->symbolStack, nonTerminal);
    lra->stateStack->push(lra->stateStack,
                          currentState->gotoes[NR_GOTO_TABLE_COLUMN]);
}

    接下来是consumeToken函数，这个函数的职责是在SLR(1)分析预测表中寻找函数入口地址并进入。如果在表内对应的项目为NULL，那么就中断。中断的原因有这么几个：错误；当前LR分析器是个受委托的分析器，遇到外层反花括号；当前分析结束，已经转到状态LRState1（留心观察一下预测分析表的构造，状态LRState1对任何终结符都没有兴趣）。现在我们需要将正常状态和错误状态进行区分。首先，如果在中断时当前状态栈栈顶是状态LRState1，那么这时一个基本块已经被正确识别了；然后，如果当前栈顶的是状态LRState0，那么有一种情况也是正常的，那就是遇到的是一个反花括号，也就是说输入是 "{ }" 空的语句块，读入正花括号后委托进入一个新LR分析器，接着这个分析器马上就遇到了反括号，因此栈顶还是初始状态。除此之外，就是出现了错误情况。

static void wrapname(consumeToken)(void* self, struct Token* token)
{
    struct LRAnalyser* lra = (struct LRAnalyser*)self;
    struct LRState* lrState = (struct LRState*)
                              (lra->stateStack->peek(lra->stateStack));
    if(NULL != lrState->actions[token->type]) {
        lrState->actions[token->type](lra, token); // 正常action
    } else {
        struct AbstractSyntaxNode* ret;
        struct LRState* topState = (struct LRState*)(lra->stateStack->pop(lra->stateStack));
        if((jerryLRStates + LRState0 == topState && RBRACE == token->type)
           || jerryLRStates + LRState1 == topState) {
            ret = lra->symbolStack->pop(lra->symbolStack); // 如果是空语句块，那么得到的是 NULL
            // 清理当前分析器
            struct SyntaxAnalyser* analyser = (struct SyntaxAnalyser*)
                                             (analyserStack->peek(analyserStack));
            analyser->consumeNonTerminal(analyser, ret);
            analyser = (struct SyntaxAnalyser*)
                       (analyserStack->peek(analyserStack));
            analyser->consumeToken(analyser, token);
        } else {
            // 出错
        }
    }
}

    在没有错误的情况下清理分析器是一件简单的事情，因为此时符号栈应该已经空了，所以只需要调用栈的析构函数，而不需关心非终结符。

static void wrapname(cleanup)(struct LRAnalyser* self)
{
    struct AbstractSyntaxNode* node;
    self->symbolStack->finalize(self->symbolStack);
    revert(self->symbolStack);
    self->stateStack->finalize(self->stateStack);
    revert(self->stateStack);

    analyserStack->pop(analyserStack); // 弹出自己
    revert(self);
}

    最后就是分析器的构造函数了。

struct SyntaxAnalyser* newLRAnalyser(void)
{
    struct LRAnalyser* analyser = (struct LRAnalyser*)
                                          allocate(sizeof(struct LRAnalyser));

    analyser->symbolStack = newStack();
    analyser->stateStack = newStack();
    analyser->stateStack->push(analyser->stateStack, jerryLRStates);

    analyser->consumeToken = wrapname(consumeToken);
    analyser->consumeNonTerminal = wrapname(consumeNonTerminal);

    return (struct SyntaxAnalyser*)analyser;
}

在构造时，会向状态栈中压入初始状态jerryLRStates( + 0)，也就是状态LRState0。这样一个LR分析器就完成了。

附：LR分析器及预测分析表不含错误处理部分的代码

    错误处理会在某个时候集中进行。

 

#include<stdlib.h>
#include"datastruct.h"
#include"syntax-analyser.h"
#include"syntax-node.h"

#include"COOL/MemoryAllocationDebugger.h"
#include"COOL/Stack/Stack.h"

extern struct Stack* analyserStack;
extern struct SyntaxAnalyser* newVariableAnalyser(void);
extern struct SyntaxAnalyser* newOperationAnalyser(void);

static struct LRState* jerryLRStates = NULL;

#define linkName(f, l) f ## _m_ ## l

#define popStateStack(stack, nr) (stack)->pops(stack, nr, NULL)
static void linkName(BasicBlock, Null)(struct LRAnalyser* analyser)
{
    analyser->symbolStack->push(analyser->symbolStack, NULL);
}

static void linkName(BasicBlock, SentenceBasicBlock)
                                 (struct LRAnalyser* analyser)
{
    struct AbstractSyntaxNode* block = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    struct AbstractSyntaxNode* sentence = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    if(NULL != sentence) {
        sentence->nextNode = block;
        block = sentence;
    }
    analyser->symbolStack->push(analyser->symbolStack, block);
    popStateStack(analyser->stateStack, 2);
}

static void linkName(Sentence, EoS)(struct LRAnalyser* analyser)
{
    analyser->symbolStack->push(analyser->symbolStack, NULL);
    popStateStack(analyser->stateStack, 1);
}

static void linkName(Sentence, IfElseBranch)(struct LRAnalyser* analyser)
{
    struct AbstractSyntaxNode* invalidSuit = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    struct AbstractSyntaxNode* validSuit = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    struct AbstractValueNode* condition = (struct AbstractValueNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    analyser->symbolStack->push(analyser->symbolStack,
                              newIfElseNode(condition, validSuit, invalidSuit));
    popStateStack(analyser->stateStack, 6);
}

static void linkName(Sentence, WhileLoop)(struct LRAnalyser* analyser)
{
    struct AbstractSyntaxNode* loop = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    struct AbstractValueNode* condition = (struct AbstractValueNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    analyser->symbolStack->push(analyser->symbolStack,
                                newWhileNode(condition, loop));
    popStateStack(analyser->stateStack, 5);
}

static void linkName(Sentence, TypeVariableRegisterEoS)
                               (struct LRAnalyser* analyser)
{
    popStateStack(analyser->stateStack, 3);
}

static void linkName(Sentence, IOAssignmentEoS)(struct LRAnalyser* analyser)
{
    struct AbstractValueNode* expression = (struct AbstractValueNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    struct IONode* node = (struct IONode*)(analyser->symbolStack->
                                           peek(analyser->symbolStack));
    node->expression = expression;
    popStateStack(analyser->stateStack, 3);
}

static void linkName(Sentence, AssignmentEoS)(struct LRAnalyser* analyser)
{
    struct AbstractValueNode* arith = (struct AbstractValueNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    analyser->symbolStack->push(analyser->symbolStack,
                                newArithmaticNode(arith));
    popStateStack(analyser->stateStack, 2);
}

static void linkName(Sentence, BreakEoS)(struct LRAnalyser* analyser)
{
    analyser->symbolStack->push(analyser->symbolStack, newBreakNode());
    popStateStack(analyser->stateStack, 2);
}

static void linkName(ElseBlock, Null)(struct LRAnalyser* analyser)
{
    analyser->symbolStack->push(analyser->symbolStack, NULL);
}

static void linkName(ElseBlock, ElseBasicBlock)(struct LRAnalyser* analyser)
{
    popStateStack(analyser->stateStack, 2);
}

static void linkName(Initialization, Null)(struct LRAnalyser* analyser)
{
    analyser->symbolStack->push(analyser->symbolStack, NULL);
}

static void linkName(Sentence, LBraceBasicBlockRBrace)
                               (struct LRAnalyser* analyser)
{
    struct AbstractSyntaxNode* innerBlock = (struct AbstractSyntaxNode*)
                            (analyser->symbolStack->pop(analyser->symbolStack));
    analyser->symbolStack->push(analyser->symbolStack,
                                newBasicBlockNode(innerBlock));
    popStateStack(analyser->stateStack, 3);
}

static void linkName(Initialization, AssignAssignment)
                               (struct LRAnalyser* analyser)
{
    popStateStack(analyser->stateStack, 2);
}

static void linkName(VariableRegister, VariableInitialization)
                                       (struct LRAnalyser* analyser)
{
    void* initialValue = analyser->symbolStack->pop(analyser->symbolStack);
    void* variable = analyser->symbolStack->pop(analyser->symbolStack);

    struct DeclarationNode* decl = (struct DeclarationNode*)
                                       (analyser->symbolStack->
                                                 peek(analyser->symbolStack));
    decl->vars->enqueue(decl->vars, variable);
    decl->initVals->enqueue(decl->initVals, initialValue);
    popStateStack(analyser->stateStack, 2);
}

#define shift(current, encounter, target)                                 \
    static void linkName(current, encounter)(struct LRAnalyser* self,     \
                                             struct Token* t)             \
    {                                                                     \
        self->stateStack->push(self->stateStack, jerryLRStates + target); \
    } /*******************************************************************/
shift(Sentence_AssignmentEoS_1, EOS, Sentence_AssignmentEoS_2)
shift(Sentence_BreakEoS_1, EOS, Sentence_BreakEoS_2)
shift(Sentence_LBraceBasicBlockRBrace_2, RBRACE,
      Sentence_LBraceBasicBlockRBrace_3)
shift(IfElseBranch_1, LPARENT, IfElseBranch_2)
shift(IfElseBranch_3, RPARENT, IfElseBranch_4)
shift(IfElseBranch_5, ELSE, ElseBlock_1)
shift(WhileLoop_1, LPARENT, WhileLoop_2)
shift(WhileLoop_3, RPARENT, WhileLoop_4)
shift(VariableRegister_VariableInitialization_1, ASSIGN,
      Initialization_AssignAssignment_1)
shift(DeclarationVariableRegister, EOS, Declaration_3)
shift(Sentence_IOAssignmentEoS_2, EOS, Sentence_IOAssignmentEoS_3)
#define shiftFirstSentence(current)                                         \
    shift(current, EOS,    Sentence_EoS_1)                                  \
    shift(current, LBRACE, Sentence_LBraceBasicBlockRBrace_1)               \
    shift(current, IF,     IfElseBranch_1)                                  \
    shift(current, WHILE,  WhileLoop_1)                                     \
    shift(current, BREAK,  Sentence_BreakEoS_1)                             \
    static void linkName(current, INTEGER_TYPE)(struct LRAnalyser* self,    \
                                                 struct Token* t)           \
    {                                                                       \
        self->symbolStack->push(self->symbolStack,                          \
                                newDeclarationNode(t->type));               \
        self->stateStack->push(self->stateStack,                            \
                               jerryLRStates + Declaration_1);              \
    }                                                                       \
                                                                            \
    static void linkName(current, REAL_TYPE)(struct LRAnalyser* self,       \
                                              struct Token* t)              \
    {                                                                       \
        self->symbolStack->push(self->symbolStack,                          \
                                newDeclarationNode(t->type));               \
        self->stateStack->push(self->stateStack,                            \
                               jerryLRStates + Declaration_1);              \
    }                                                                       \
                                                                            \
    static void linkName(current, READ)(struct LRAnalyser* self,            \
                                        struct Token* t)                    \
    {                                                                       \
        self->symbolStack->push(self->symbolStack, newIONode(t->type));     \
        self->stateStack->push(self->stateStack,                            \
                               jerryLRStates + Sentence_IOAssignmentEoS_1); \
    }                                                                       \
                                                                            \
    static void linkName(current, WRITE)(struct LRAnalyser* self,           \
                                         struct Token* t)                   \
    {                                                                       \
        self->symbolStack->push(self->symbolStack, newIONode(t->type));     \
        self->stateStack->push(self->stateStack,                            \
                               jerryLRStates + Sentence_IOAssignmentEoS_1); \
    } /*********************************************************************/
shiftFirstSentence(LRState0)
shiftFirstSentence(BasicBlock_SentenceBasicBlock_1)
shiftFirstSentence(IfElseBranch_4)
shiftFirstSentence(WhileLoop_4)
shiftFirstSentence(ElseBlock_1)
#undef shiftFirstSentence
#undef shift

static void linkName(DeclarationVariableRegister, COMMA)
                                      (struct LRAnalyser* self, struct Token* t)
{
    popStateStack(self->stateStack, 1);
}

#undef popStateStack

#define switchAnalyser(current, encounter, analyser)                  \
    static void linkName(current, encounter)(struct LRAnalyser* self, \
                                             struct Token* t)         \
    {                                                                 \
        struct SyntaxAnalyser* delegateAnalyser = (analyser);         \
        analyserStack->push(analyserStack, delegateAnalyser);         \
        delegateAnalyser->consumeToken(delegateAnalyser, t);          \
    } /***************************************************************/
switchAnalyser(Declaration_1, IDENT,  newVariableAnalyser())
#define switchAnalyserFirstAssignment(current, analyser) \
    switchAnalyser(current, PLUS,    analyser)           \
    switchAnalyser(current, MINUS,   analyser)           \
    switchAnalyser(current, NOT,     analyser)           \
    switchAnalyser(current, INTEGER, analyser)           \
    switchAnalyser(current, REAL,    analyser)           \
    switchAnalyser(current, IDENT,   analyser)           \
    switchAnalyser(current, LPARENT, analyser) /*********/
switchAnalyserFirstAssignment(LRState0,       newOperationAnalyser())
switchAnalyserFirstAssignment(IfElseBranch_2, newOperationAnalyser())
switchAnalyserFirstAssignment(WhileLoop_2,    newOperationAnalyser())
switchAnalyserFirstAssignment(IfElseBranch_4, newOperationAnalyser())
switchAnalyserFirstAssignment(WhileLoop_4,    newOperationAnalyser())
switchAnalyserFirstAssignment(ElseBlock_1,    newOperationAnalyser())
switchAnalyserFirstAssignment(Sentence_IOAssignmentEoS_1,
                              newOperationAnalyser())
switchAnalyserFirstAssignment(BasicBlock_SentenceBasicBlock_1,
                              newOperationAnalyser())
switchAnalyserFirstAssignment(Initialization_AssignAssignment_1,
                              newOperationAnalyser())
#define switchAnalyserFirstSentence(current, analyser) \
    switchAnalyser(current, IF,           analyser)    \
    switchAnalyser(current, WHILE,        analyser)    \
    switchAnalyser(current, READ,         analyser)    \
    switchAnalyser(current, WRITE,        analyser)    \
    switchAnalyser(current, BREAK,        analyser)    \
    switchAnalyser(current, INTEGER_TYPE, analyser)    \
    switchAnalyser(current, REAL_TYPE,    analyser)    \
    switchAnalyser(current, EOS,          analyser)    \
    switchAnalyser(current, LBRACE,       analyser)    \
    switchAnalyserFirstAssignment(current, analyser) ///
switchAnalyserFirstSentence(Sentence_LBraceBasicBlockRBrace_1, newLRAnalyser())
switchAnalyser(Sentence_LBraceBasicBlockRBrace_1, RBRACE, newLRAnalyser())
#undef switchAnalyserFirstSentence
#undef switchAnalyserFirstAssignment
#undef switchAnalyser

#define reduce(current, encounter, leftPart, rightPart)                    \
static void linkName(current, encounter)(struct LRAnalyser* self,          \
                                         struct Token* t)                  \
{                                                                          \
    linkName(leftPart, rightPart)(self);                                   \
    struct LRState* target = ((struct LRState*)self->stateStack->          \
                                peek(self->stateStack))->gotoes[leftPart]; \
    self->stateStack->push(self->stateStack, target);                      \
    self->consumeToken(self, t);                                           \
} /************************************************************************/
reduce(LRState0, END,    BasicBlock, Null)
reduce(LRState0, RBRACE, BasicBlock, Null)
reduce(LRState0, ELSE,   BasicBlock, Null)

reduce(BasicBlock_SentenceBasicBlock_1, END,    BasicBlock, Null)
reduce(BasicBlock_SentenceBasicBlock_1, RBRACE, BasicBlock, Null)
reduce(BasicBlock_SentenceBasicBlock_1, ELSE,   BasicBlock, Null)

reduce(VariableRegister_VariableInitialization_1, EOS,   Initialization, Null)
reduce(VariableRegister_VariableInitialization_1, COMMA, Initialization, Null)

reduce(IfElseBranch_5, RBRACE, ElseBlock, Null)
reduce(IfElseBranch_5, END,    ElseBlock, Null)
#define reduceFirstSentence(current, leftPart, rightPart) \
    reduce(current, IF,           leftPart, rightPart)    \
    reduce(current, WHILE,        leftPart, rightPart)    \
    reduce(current, READ,         leftPart, rightPart)    \
    reduce(current, WRITE,        leftPart, rightPart)    \
    reduce(current, BREAK,        leftPart, rightPart)    \
    reduce(current, INTEGER_TYPE, leftPart, rightPart)    \
    reduce(current, REAL_TYPE,    leftPart, rightPart)    \
    reduce(current, INTEGER,      leftPart, rightPart)    \
    reduce(current, REAL,         leftPart, rightPart)    \
    reduce(current, NOT,          leftPart, rightPart)    \
    reduce(current, PLUS,         leftPart, rightPart)    \
    reduce(current, MINUS,        leftPart, rightPart)    \
    reduce(current, IDENT,        leftPart, rightPart)    \
    reduce(current, EOS,          leftPart, rightPart)    \
    reduce(current, LBRACE,       leftPart, rightPart)    \
    reduce(current, LPARENT,      leftPart, rightPart) /**/
reduceFirstSentence(IfElseBranch_5, ElseBlock, Null)
#define reduceAny(current, leftPart, rightPart)        \
    reduceFirstSentence(current, leftPart, rightPart)  \
    reduce(current, END,          leftPart, rightPart) \
    reduce(current, ELSE,         leftPart, rightPart) \
    reduce(current, MULTIPLY,     leftPart, rightPart) \
    reduce(current, DIVIDE,       leftPart, rightPart) \
    reduce(current, ASSIGN,       leftPart, rightPart) \
    reduce(current, LT,           leftPart, rightPart) \
    reduce(current, LE,           leftPart, rightPart) \
    reduce(current, EQ,           leftPart, rightPart) \
    reduce(current, GT,           leftPart, rightPart) \
    reduce(current, GE,           leftPart, rightPart) \
    reduce(current, NE,           leftPart, rightPart) \
    reduce(current, AND,          leftPart, rightPart) \
    reduce(current, OR,           leftPart, rightPart) \
    reduce(current, COMMA,        leftPart, rightPart) \
    reduce(current, RPARENT,      leftPart, rightPart) \
    reduce(current, LBRACKET,     leftPart, rightPart) \
    reduce(current, RBRACKET,     leftPart, rightPart) \
    reduce(current, RBRACE,       leftPart, rightPart)
reduceAny(Sentence_EoS_1, Sentence, EoS)
reduceAny(BasicBlock_SentenceBasicBlock_2, BasicBlock, SentenceBasicBlock)
reduceAny(Sentence_IOAssignmentEoS_3, Sentence, IOAssignmentEoS)
reduceAny(IfElseBranch_6, Sentence, IfElseBranch)
reduceAny(ElseBlock_2, ElseBlock, ElseBasicBlock)
reduceAny(WhileLoop_5, Sentence, WhileLoop)
reduceAny(Sentence_AssignmentEoS_2, Sentence, AssignmentEoS)
reduceAny(Sentence_BreakEoS_2, Sentence, BreakEoS)
reduceAny(Declaration_3, Sentence, TypeVariableRegisterEoS)
reduceAny(Sentence_LBraceBasicBlockRBrace_3, Sentence, LBraceBasicBlockRBrace)
reduceAny(Initialization_AssignAssignment_2, Initialization, AssignAssignment)
reduceAny(VariableRegister_VariableInitialization_2, VariableRegister,
          VariableInitialization)
#undef reduceAny
#undef reduce

void initialLRStates(void)
{
    jerryLRStates = (struct LRState*)
                            allocate(NR_LR_STATE * sizeof(struct LRState));
    memset(jerryLRStates, 0, NR_LR_STATE * sizeof(struct LRState));
#define setAction(state, encounter)                                    \
        jerryLRStates[state].actions[encounter] = linkName(state, encounter)
    setAction(LRState0, END);
    setAction(LRState0, RBRACE);
    setAction(LRState0, ELSE);
    setAction(BasicBlock_SentenceBasicBlock_1, END);
    setAction(BasicBlock_SentenceBasicBlock_1, RBRACE);
    setAction(BasicBlock_SentenceBasicBlock_1, ELSE);
    setAction(Sentence_AssignmentEoS_1, EOS);
    setAction(Sentence_BreakEoS_1, EOS);
    setAction(Sentence_LBraceBasicBlockRBrace_2, RBRACE);
    setAction(IfElseBranch_1, LPARENT);
    setAction(IfElseBranch_3, RPARENT);
    setAction(IfElseBranch_5, ELSE);
    setAction(IfElseBranch_5, RBRACE);
    setAction(IfElseBranch_5, END);
    setAction(WhileLoop_1, LPARENT);
    setAction(WhileLoop_3, RPARENT);
    setAction(VariableRegister_VariableInitialization_1, ASSIGN);
    setAction(DeclarationVariableRegister, EOS);
    setAction(DeclarationVariableRegister, COMMA);
    setAction(Sentence_IOAssignmentEoS_2, EOS);
    setAction(VariableRegister_VariableInitialization_1, EOS);
    setAction(VariableRegister_VariableInitialization_1, COMMA);
    setAction(Declaration_1, IDENT);
    #define setActionFirstAssignment(state) \
        setAction(state, PLUS);             \
        setAction(state, MINUS);            \
        setAction(state, NOT);              \
        setAction(state, INTEGER);          \
        setAction(state, REAL);             \
        setAction(state, IDENT);            \
        setAction(state, LPARENT) /*********/
    setActionFirstAssignment(IfElseBranch_2);
    setActionFirstAssignment(WhileLoop_2);
    setActionFirstAssignment(Sentence_IOAssignmentEoS_1);
    setActionFirstAssignment(Initialization_AssignAssignment_1);
    #define setActionFirstSentence(state) \
        setAction(state, EOS);            \
        setAction(state, READ);           \
        setAction(state, WRITE);          \
        setAction(state, IF);             \
        setAction(state, WHILE);          \
        setAction(state, BREAK);          \
        setAction(state, INTEGER_TYPE);   \
        setAction(state, REAL_TYPE);      \
        setAction(state, LBRACE);         \
        setActionFirstAssignment(state) ///
    setActionFirstSentence(LRState0);
    setActionFirstSentence(BasicBlock_SentenceBasicBlock_1);
    setActionFirstSentence(IfElseBranch_4);
    setActionFirstSentence(IfElseBranch_5);
    setActionFirstSentence(WhileLoop_4);
    setActionFirstSentence(ElseBlock_1);
    setActionFirstSentence(Sentence_LBraceBasicBlockRBrace_1);
    setAction(Sentence_LBraceBasicBlockRBrace_1, RBRACE);
    #define setActionAny(state)         \
        setAction(state, END);          \
        setAction(state, ELSE);         \
        setAction(state, MULTIPLY);     \
        setAction(state, DIVIDE);       \
        setAction(state, ASSIGN);       \
        setAction(state, LT);           \
        setAction(state, LE);           \
        setAction(state, EQ);           \
        setAction(state, GT);           \
        setAction(state, GE);           \
        setAction(state, NE);           \
        setAction(state, AND);          \
        setAction(state, OR);           \
        setAction(state, COMMA);        \
        setAction(state, RPARENT);      \
        setAction(state, LBRACKET);     \
        setAction(state, RBRACKET);     \
        setAction(state, RBRACE);       \
        setActionFirstSentence(state) ///
    setActionAny(Sentence_EoS_1);
    setActionAny(BasicBlock_SentenceBasicBlock_2);
    setActionAny(Sentence_IOAssignmentEoS_3);
    setActionAny(IfElseBranch_6);
    setActionAny(ElseBlock_2);
    setActionAny(WhileLoop_5);
    setActionAny(Sentence_AssignmentEoS_2);
    setActionAny(Sentence_BreakEoS_2);
    setActionAny(Sentence_LBraceBasicBlockRBrace_3);
    setActionAny(Initialization_AssignAssignment_2);
    setActionAny(VariableRegister_VariableInitialization_2);
    setActionAny(Declaration_3);
    #undef setActionFirstAssignment
    #undef setActionFirstSentence
    #undef setActionAny
    #undef setAction

    #define setGoto(state, nonTerminal, target)                         \
        jerryLRStates[state].gotoes[nonTerminal] = jerryLRStates + target
    setGoto(LRState0, BasicBlock, LRState1);
    setGoto(LRState0, Sentence, BasicBlock_SentenceBasicBlock_1);
    setGoto(BasicBlock_SentenceBasicBlock_1, Sentence,
            BasicBlock_SentenceBasicBlock_1);
    setGoto(BasicBlock_SentenceBasicBlock_1, BasicBlock,
            BasicBlock_SentenceBasicBlock_2);
    setGoto(WhileLoop_4, Sentence, WhileLoop_5);
    setGoto(IfElseBranch_4, Sentence, IfElseBranch_5);
    setGoto(IfElseBranch_5, ElseBlock, IfElseBranch_6);
    setGoto(ElseBlock_1, Sentence, ElseBlock_2);
    setGoto(VariableRegister_VariableInitialization_1, Initialization,
            VariableRegister_VariableInitialization_2);
    setGoto(Declaration_1, VariableRegister, DeclarationVariableRegister);
    #undef setGoto

    #define extraGoto(source, target)                                         \
    jerryLRStates[source].gotoes[NR_GOTO_TABLE_COLUMN] = jerryLRStates + target
    extraGoto(LRState0,                        Sentence_AssignmentEoS_1);
    extraGoto(IfElseBranch_4,                  Sentence_AssignmentEoS_1);
    extraGoto(ElseBlock_1,                     Sentence_AssignmentEoS_1);
    extraGoto(WhileLoop_4,                     Sentence_AssignmentEoS_1);
    extraGoto(BasicBlock_SentenceBasicBlock_1, Sentence_AssignmentEoS_1);

    extraGoto(Sentence_LBraceBasicBlockRBrace_1,
              Sentence_LBraceBasicBlockRBrace_2);
    extraGoto(IfElseBranch_2, IfElseBranch_3);
    extraGoto(WhileLoop_2, WhileLoop_3);
    extraGoto(Sentence_IOAssignmentEoS_1, Sentence_IOAssignmentEoS_2);
    extraGoto(Initialization_AssignAssignment_1,
              Initialization_AssignAssignment_2);
    extraGoto(Declaration_1, VariableRegister_VariableInitialization_1);
    #undef extraGoto
}

#undef linkName

void destructLRStates(void)
{
    revert(jerryLRStates);
    jerryLRStates = NULL;
}

#define wrapname(name) name ## _LRAnalyser
static void wrapname(cleanup)(struct LRAnalyser* self)
{
    struct AbstractSyntaxNode* node;
    self->symbolStack->finalize(self->symbolStack);
    self->stateStack->finalize(self->stateStack);

    analyserStack->pop(analyserStack);
    revert(self);
}

static void wrapname(consumeToken)(void* self, struct Token* token)
{
    struct LRAnalyser* lra = (struct LRAnalyser*)self;
    struct LRState* lrState = (struct LRState*)
                              (lra->stateStack->peek(lra->stateStack));
    if(NULL != lrState->actions[token->type]) {
        lrState->actions[token->type](lra, token);
    } else {
//        printf("Interrupt LR\n");
        struct AbstractSyntaxNode* ret;
        struct LRState* topState = (struct LRState*)
                                        (lra->stateStack->pop(lra->stateStack));
        if((jerryLRStates + LRState0 == topState && RBRACE == token->type)
           || jerryLRStates + LRState1 == topState) {
            ret = lra->symbolStack->pop(lra->symbolStack);
            wrapname(cleanup)(lra);
//        printf("Cleaned...\n");
            struct SyntaxAnalyser* analyser = (struct SyntaxAnalyser*)
                                           (analyserStack->peek(analyserStack));
            analyser->consumeNonTerminal(analyser, ret);
            analyser = (struct SyntaxAnalyser*)
                       (analyserStack->peek(analyserStack));
            analyser->consumeToken(analyser, token);
        } else {
            printf("LR ERR\n");
            printf("%s\n", token->image);
            exit(0);
        }
    }
}

static void wrapname(consumeNonTerminal)(void* self,
                                         struct AbstractSyntaxNode* nonTerminal)
{
    struct LRAnalyser* lra = (struct LRAnalyser*)self;
    struct LRState* currentState = (struct LRState*)
                                   (lra->stateStack->peek(lra->stateStack));
    lra->symbolStack->push(lra->symbolStack, nonTerminal);
    lra->stateStack->push(lra->stateStack,
                          currentState->gotoes[NR_GOTO_TABLE_COLUMN]);
}

struct SyntaxAnalyser* newLRAnalyser(void)
{
    struct LRAnalyser* analyser = (struct LRAnalyser*)
                                          allocate(sizeof(struct LRAnalyser));

    analyser->symbolStack = newStack();
    analyser->stateStack = newStack();
    analyser->stateStack->push(analyser->stateStack, jerryLRStates);

    analyser->consumeToken = wrapname(consumeToken);
    analyser->consumeNonTerminal = wrapname(consumeNonTerminal);

    return (struct SyntaxAnalyser*)analyser;
}
#undef wrapname

 

 

iteye_10703
关注
编译原理-实现LR语法分析器——沐雨先生
Movrain的博客
03-19 2143
编译原理-实现LR语法分析器
【编译原理】LR语法分析器的设计与实现
PKM of bk
10-23 8547
本文为当时编译原理实验作业，要求用设计的思想完成LR语法分析器的设计与实现，小题大做，仅供参考
LR(1)分析器构造
05-27
编译原理课程设计报告：输入文法，构造出相应的LR(1)有效项目集族
编译原理实验LR分析表构造LR分析器
07-11
LR分析器工作过程算法描述： 一个LR分析器的工作过程可看成是栈里的状态序列，已规约串和输入串所构成的三元式的变化过程。分析开始时的初始三元式为 (s0, #, a1a2……an#) 其中，s0为分析器的初态；＃为句子的左括号；a1a2……an为输入串；其后的＃为结束符（句子右括号）。分析过程每步的结果可表示为 （s0s1……sm， #X1X2……Xm ai, ai+1……an#） 分析器的下一步动作是由栈顶状态sm和现行输入符号ai所唯一决定的。即，执行ACTION（sm，ai）所规定的动作。经执行每种可能的动作之后，三元式的变化情形是： （1） 若ACTION（sm，ai）为移进，且s = GOTO（sm，ai），则三元式变成： （s0s1……sm s， #X1X2……Xm ai, ai+1……an#） （2） 若ACTION（sm，ai）= {A→β},则按照产生式A→β进行规约。此时三元式变为 （s0s1……sm s， #X1X2……Xm A, ai ai+1……an#） 此处s = GOTO（Sm-r，A），r为β的长度，β = Xm-r+1……Xm。 （3） 若ACTION（sm，ai）为“接受”，则三元式不再变化，变化过程终止，宣布分析成功。 （4） 若ACTION（sm，ai）为“报错”，则三元式的变化过程终止，报告错误。 一个LR分析器的工作过程就是一步一步的变换三元式，直至执行“接受”或“报错”为止。
LR 语法分析器
SonicLing的专栏
04-10 1万+
下载地址 LR语法分析器算是基本完成了，只需要一个文法定义文件（.syntax），就可以进行对应语言的语法分析，最后形成语法树。词法分析是固定的，采用C++的词法定义。以后将加入动态的词法分析。压缩包中文件的描述：LRTable.exe 是用文法定义文件（syntax文件）生成LR动作表文件（action文件），使用方法在 1_build_actio
LR(0)语法分析器程序
04-16
C语言实现的LR(0)语法分析器程序，能用于大多数LR型文法分析，程序只需局部修改就可使用。
LR(1)语法分析表生成
05-01
可以根据你输入的文法和first集合生成LR（1）分析表。
lR语法分析器设计.pdf
06-24
LR语法分析器是一种用于解析上下文无关文法的高效工具，广泛应用于编译器设计中。LR分析器从左向右扫描输入字符串，并自底向上地进行语法分析，旨在判断输入字符串是否符合文法的语句。以下是关于LR分析器设计的一些...
编译原理实验之词法分析器、LL(1)语法分析器、LR(1)语法分析器.zip
09-20
这是编译原理的第一个实验，算是热身实验吧，确实很简单，花了一晚上就把词法分析器底层部分写完了，老师比较喜欢图形界面，后来又加了前端，也就是现在看到的效果。实验要求能够匹配出关键字、标记符、运算符、分界...
用c++实现LR语法分析器
12-28
通过LR分析表及三个栈形成对输入表达式的判断！ 。
新版C++完整实现LR1语法分析器项目
最新发布
07-12
项目中包含的关键文件名为“C++实现LR(1)语法分析器.txt”，它可能包含了语法分析器的设计思路、算法原理、具体实现代码以及必要的注释说明。文件中应该详细说明了如何使用C++语言构建LR(1)分析表，以及如何使用这个...
同济大学计算机系课程《编译原理》大作业项目词法分析器LR1语法分析器.zip
04-17
同济大学计算机系课程《编译原理》大作业项目词法分析器LR1语法分析器 同济大学计算机系的《编译原理》课程的大作业项目包括词法分析器和LR1语法分析器的实现。这个项目是编译原理课程中的一个重要实践环节，旨在...
[编译原理]构造LR分析器和SLR移进归约分析表
習習君的博客
05-24 5207
本篇文章通过文法构造SLR分析表，然后构造LR分析器。然后通过编码将其实现（本篇主题）。用了两种风格代码实现，分别为java和JavaScript。
第五章 LR分析法
热门推荐
yongchaocsdn的博客
12-03 3万+
LR分析法也是一种“移进—归约”的自底向上语法分析方法，其本质是规范归约，具有以下特点： (1)应用面广：能够用LR分析程序识别绝大多数的程序设计语言的语法结构； (2)实现效率高：虽构造方法复杂，但是实现（执行）效率高。 (3)查错准确：LR分析器能够及时发现语法错误并准确指出错误位置。 LR(k)分析方法中L是指自左(Left)向右扫描输入单词串，R指分析过程是最右(Right)推
LR语法分析-简单的LR技术
jlr_6的专栏
04-04 3699
LR语法分析-简单的LR技术LR语法分析是由表格驱动的。项和LR(0)自动机项：用来表示在语法分析过程中是进行移入还是进行规约的状态。一个文法产生式的项是它的产生式加上产生体中的一个。如：A -> XYZ的项：A -> .XYZA -> X.YZA -> XY.ZA -> XYZ.项集表示了在语法分析过程的给定点上，我们已经看到了产生式中的哪个部
编译原理-6-LR语法分析器
SpriCoder的博客
02-26 7201
6-LR语法分析器
3.5 LR分析器
tang7mj的博客
02-07 2102
一个文法被称为LR文法，如果能为其构造一个所有条目都唯一的LR分析表。这意味着，当句柄出现在栈顶时，LR分析器可以凭借栈顶的状态符号及向前看的k个符号（通常是0或1）来及时识别句柄，无需扫描整个栈。这种能力使LR分析器在自左向右扫描输入时非常高效。构造SLR分析表是理解LR分析方法的起点，提供了一种相对简单的方式来构建LR分析器。SLR分析器使用的SLR分析表基于SLR方法，该方法通过识别文法的活前缀来指导分析器的移进-归约决策。活前缀是文法右句型的前缀，不超过该右句型的最右句柄的右端。
【编译原理】一篇搞定LR分析法（LR(1)、LR(0)、SLR、LALR）
十二月的猫
12-24 6323
上下文无关文法的LR分析法LR：自左至右扫描，最右推导的逆过程（也就是最左归约）本文到这里就结束啦~~本系列专栏将专注于【编译原理】知识。【编译原理】编译原理知识点汇总·概论与文法-优快云博客【编译原理】编译原理知识点汇总·词法分析器（正则式到NFA、NFA到DFA、DFA最小化）-优快云博客【编译原理】词法分析器设计（山东大学实验一）_山东大学编译原理实验-优快云博客。
编译原理实验4_语法分析程序 LR（1）
肉夹馍的博客
11-27 1064
编译原理实验4_语法分析程序 LR（1）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值