C++ |N_SIMPLE_EXPR N_REL_OP N_SIMPLE_EXPR { 打印规则（“EXPR”、“SIMPLE_EXPR REL_OP SIMPLE_EXPR”）； } ; N_简单表达式：N_术语N_添加操作 { 打印规则（“简单表达式”、“术语添加操作”）； } ; N_ADD_OP_LST://Epsilon { printRule（“ADD_OP_LST”、“epsilon”）； } |N_添加操作N_术语N_添加操作 { 打印规则（“添加操作”、“添加操作术语添加操作”）； } ; N_项：N_因子N_倍数 { 打印规则（“术语”、“多因素操作”）； } ; N\u MULT\u OP\u LST://Epsilon { 打印规则（“MULT_OP_LST”、“epsilon”）； } |N_MULT_OP N_因子N_MULT_OP LST { 打印规则（“多因素多因素”）； } ; N_因子：N_符号N_变量 { 打印规则（“因子”、“符号变量”）； } |N_常数 { 打印规则（“系数”、“常数”）； } |我的朋友们，我的朋友们 { 打印规则（“因子”，“表达式”）； } |T_非N_因素 { 打印规则（“因子”、“非因子”）； } ; 符号：／ε { 打印规则（“符号”、“ε”）； } |图加 { 打印规则（“符号“，“+”）； } |T_减号 { 打印规则（“符号”、“-”）； } ; N_ADD_OP:T_PLUS { printRule（“ADD_OP”，“+”）； } |T_减号 { printRule（“添加操作“，”-”）； } |托奥 { 打印规则（“添加操作”、“或”）； } ; N_MULT_OP:T_MULT { printRule（“MULT_OP”，“*”）； } |大埔分区 { printRule（“MULT_OP”，“/”）； } |图和 { printRule（“MULT_OP”，“and”）； } ; N_REL_OP:T_LT { 打印规则（“REL_OP”，”）； } |图勒 { printRule（“REL_OP”，“=”）； } |T_EQ { printRule（“REL_OP”，“=”）； } ; N_变量：N_整个变量 { printRule（“VAR”、“整个VAR”）； } |N_IDX_VAR { 打印规则（“VAR”、“IDX_VAR”）； } ; N_IDX_VAR:N_数组_VAR T_LBRACK N_EXPR T_RBRACK { printRule（“IDX_VAR”，“ARRAY_VAR（EXPR）”）； } ; N_数组变量：N_整个变量 { printRule（“数组变量”、“整个变量”）； } ; N_整个变量：N_变量标识 { 打印规则（“整个变量”、“变量标识”）； } ; N_VAR_IDENT:T_IDENT { 打印规则（“VAR_IDENT”、“IDENT”）； } ; N_CONST:N_INTCONST { 打印规则（“常量”、“INTCONST”）； } |T_CHARCONST { 打印规则（“常量”、“CHARCONST”）； } |N_BOOLCONST { 打印规则（“CONST”、“BOOLCONST”）； } ; N_INTCONST:N_符号T_INTCONST { 打印规则（“INTCONST”、“SIGN INTCONST”）； } ; N_BOOLCONST:没错 { 打印规则（“BOOLCONST”、“true”）； } |图假 { 打印规则（“BOOLCONST”、“false”）； } ; %% #包括“lex.yy.c” 外部文件*yyin； 无效打印规则（常量字符*lhs，常量字符*rhs）{ printf（“%s->%s\n”，左侧，右侧）； 返回； } int yyerror（常量字符*s）{ printf（“%s\n”，s）； 申报表（1）； } void printTokenInfo（常量字符*标记类型，常量字符*词素）{ printf（“令牌：%s词素：%s\n”，令牌类型，词素）； } int main（）{ 做{ yyparse（）； }而（！feof（yyin））； printf（“%d行已处理\n”，numLines）； 返回0； }

有什么想法吗？

根据你的语法，每个

N\u块

必须包含一个

N\u程序段

，每个

N\u程序段

必须包含一个

N\u块

。这种无限递归使得

N_BLOCK

和

N_PROC_DEC

不可能成功匹配任何东西，而且由于

N_START

需要

N_BLOCK

，因此

N_START

也不可能成功。

教我在深夜抄写作业。谢谢！：）我知道这一定是一个递归错误，因为我看到了这个问题的所有其他答案。我想我只是需要一双新眼睛。再次感谢。：）

%error-verbose
%{

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string>
#include <cstring>

using namespace std;

void printTokenInfo(char* tokenType, char* lexeme);
void printRule(const char *lhs, const char *rhs);
int yyerror(const char *s);

int numLines = 0; 

extern "C" {
 int yyparse(void);
 int yylex(void);
 int yywrap() { return 1; }
}

%}

/* Token declarations */
%token T_ASSIGN T_MULT T_PLUS T_MINUS T_DIV
%token T_AND T_OR T_NOT T_LT T_GT
%token T_LE T_GE T_EQ T_NE T_VAR
%token T_ARRAY T_OF T_BOOL T_CHAR T_INT
%token T_PROG T_PROC T_BEGIN T_END T_WHILE
%token T_DO T_IF T_READ T_UNKNOWN
%token T_WRITE T_TRUE T_FALSE T_LBRACK T_RBRACK
%token T_SCOLON T_COLON T_LPAREN T_RPAREN T_COMMA
%token T_DOT T_DOTDOT T_INTCONST T_CHARCONST T_IDENT

%nonassoc T_THEN
%nonassoc T_ELSE

/* Starting point */
%start N_START

%%
N_START : N_PROG
    {
        printRule("START", "PROG");
        return 0;
    }
    ;
N_PROG  : N_PROGLBL T_IDENT T_SCOLON N_BLOCK T_DOT
    {
        printRule("PROG", "PROG_LBL ident ; BLOCK.");
    }
    ;
N_PROGLBL : T_PROG
    {
        printRule("PROG_LBL", "T_PROGTOKEN");
    }
    ;
N_BLOCK : N_VAR_DEC N_PROC_DEC N_STMT
    {
        printRule("BLOCK", "VAR_DEC PROC_DEC STMT");
    }
    ;
N_VAR_DEC_PART  :   //Epsilon
    {
        printRule("VAR_DEC_PART", "epsilon");
    }
            |   T_VAR N_VAR_DEC T_SCOLON N_VAR_DEC_LST
    {
        printRule("VAR_DEC_PART", "var VAR_DEC : VAR_DEC_LST");
    }
    ;
N_VAR_DEC_LST   :   //Epsilon
    {
        printRule("VAR_DEC_LST", "epsilon");
    }
                |   N_VAR_DEC T_SCOLON N_VAR_DEC_LST
    {
        printRule("VAR_DEC_LST", "VAR_DEC : VAR_DEC_LST");
    }
    ;
N_VAR_DEC   :   T_IDENT N_VAR_DEC_LST T_COLON N_TYPE
    {
        printRule("VAR_DEC", "ident VAR_DEC_LST : TYPE");
    }
    ;
N_IDENT     :   T_IDENT
    {
        printRule("IDENT", "ident");
    }
    ;
N_IDENT_LST :   //Epsilon
    {
        printRule("IDENT_LST", "epsilon");
    }
            |   T_COMMA N_IDENT N_IDENT_LST
    {
        printRule("IDENT_LST", ", IDENT IDENT_LST");
    }
    ;
N_TYPE  :   N_SIMPLE
    {
        printRule("TYPE", "SIMPLE");
    }
        |   N_ARRAY
    {
        printRule("TYPE", "ARRAY");
    }
    ;
N_ARRAY :   T_ARRAY T_LBRACK N_IDX_RANGE T_RBRACK T_OF N_SIMPLE
    {
        printRule("ARRAY", "ARRAY ( IDX_RANGE ) of SIMPLE");
    }
    ;
N_IDX   :   N_INTCONST
    {
        printRule("IDX", "IN_CONST");
    }
    ;
N_IDX_RANGE :   N_IDX T_DOTDOT N_IDX
    {
        printRule("IDX_RANGE", "IDX .. IDX");
    }
    ;
N_SIMPLE    :   T_INTCONST
    {
        printRule("SIMPLE", "intconst");
    }
            |   T_CHARCONST
    {
        printRule("SIMPLE", "charconst");
    }
            |   T_BOOL
    {
        printRule("SIMPLE", "bool");
    }
    ;
N_PROC_DEC_PART :   //Epsilon
    {
        printRule("PROC_DEC_PART", "epsilon");
    }
                |   N_PROC_DEC T_SCOLON N_PROC_DEC_PART
    {
        printRule("PROC_DEC_PART", "PROC_DEC : PROC_DEC_PART");
    }
    ;
N_PROC_DEC  :   N_PROC_HDR N_BLOCK
    {
        printRule("PROC_DEC", "PROC_HDR BLOCK");
    }
    ;
N_PROC_HDR  :   T_PROC T_IDENT T_SCOLON
    {
        printRule("PROC_HDR", "proc ident :");
    }
    ;
N_STMT_PART :   N_COMPOUND
    {
        printRule("STMT_PART", "COMPOUND");
    }
    ;
N_COMPOUND  :   T_BEGIN N_STMT N_STMT_LST T_END
    {
        printRule("COMPOUND", "begin STMT STMT_LST end");
    }
    ;
N_STMT_LST  :   //Epsilon
    {
        printRule("STMT_LST", "epsilon");
    }
            |   T_SCOLON N_STMT N_STMT_LST
    {
        printRule("STMT_LST", ": STMT STMT_LST");
    }
    ;
N_STMT  :   N_ASSIGN
    {
        printRule("STMT", "ASSIGN");
    }
        |   N_PROC_STMT
    {
        printRule("STMT", "PROC_STMT");
    }
        |   N_READ
    {
        printRule("STMT", "READ");
    }
        |   N_WRITE
    {
        printRule("STMT", "WRITE");
    }
        |   N_CONDITION
    {
        printRule("STMT", "CONDITION");
    }
        |   N_WHILE
    {
        printRule("STMT", "WHILE");
    }
        |   N_COMPOUND
    {
        printRule("STMT", "COMPOUND");
    }
    ;
N_ASSIGN    :   N_VAR T_ASSIGN N_EXPR
    {
        printRule("ASSIGN", "VAR := EXPR");
    }
    ;
N_PROC_STMT :   N_PROC_IDENT
    {
        printRule("PROC_STMT", "PROC_IDENT");
    }
    ;
N_PROC_IDENT    :   T_IDENT
    {
        printRule("PROC_IDENT", "ident");
    }
    ;
N_READ  :   T_READ T_LPAREN N_INPUT_VAR N_INPUT_LST T_RPAREN
    {
        printRule("READ", "read ( INPUT INPUT_LST )");
    }
    ;
N_INPUT_LST :   //Epsilon
    {
        printRule("INPUT_LST", "epsilon");
    }
            |   T_COMMA N_INPUT_VAR N_INPUT_LST
    {
        printRule("INPUT_LST", ", INPUT_VAR INPUT_LST");
    }
    ;
N_INPUT_VAR :   N_VAR
    {
        printRule("INPUT_VAR", "VAR");
    }
    ;
N_WRITE :   T_WRITE T_LPAREN N_OUTPUT N_OUTPUT_LST T_RPAREN
    {
        printRule("WRITE", "write ( OUTPUT OUTPUT_LST )");
    }
    ;
N_OUTPUT_LST    :   //Epsilon
    {
        printRule("OUTPUT_LST", "epsilon");
    }
                |   T_COMMA N_OUTPUT N_OUTPUT_LST
    {
        printRule("OUTPUT_LST", ", OUTPUT OUTPUT_LST");
    }
    ;
N_OUTPUT    :   N_EXPR
    {
        printRule("OUTPUT", "EXPR");
    }
    ;
N_CONDITION :   T_IF N_EXPR T_THEN N_STMT
    {
        printRule("CONDITION", "if EXPR then STMT");
    }
            |   T_IF N_EXPR T_THEN N_STMT T_ELSE N_STMT
    {
        printRule("CONDITION", "if EXPR then STMT else STMT");
    }
    ;
N_WHILE :   T_WHILE N_EXPR T_DO N_STMT
    {
        printRule("WHILE", "while EXPR do STMT");
    }
    ;
N_EXPR  :   N_SIMPLE_EXPR
    {
        printRule("EXPR", "SIMPLE_EXPR");
    }
        |   N_SIMPLE_EXPR N_REL_OP N_SIMPLE_EXPR
    {
        printRule("EXPR", "SIMPLE_EXPR REL_OP SIMPLE_EXPR");
    }
    ;
N_SIMPLE_EXPR   :   N_TERM N_ADD_OP_LST
    {
        printRule("SIMPLE_EXPR", "TERM ADD_OP_LST");
    }
    ;
N_ADD_OP_LST    :   //Epsilon
    {
        printRule("ADD_OP_LST", "epsilon");
    }
                |   N_ADD_OP N_TERM N_ADD_OP_LST
    {
        printRule("ADD_OP_LST", "ADD_OP TERM ADD_OP_LST");
    }
    ;
N_TERM  :   N_FACTOR N_MULT_OP_LST
    {
        printRule("TERM", "FACTOR MULT_OP_LST");
    }
    ;
N_MULT_OP_LST   :   //Epsilon
    {
        printRule("MULT_OP_LST", "epsilon");
    }
                |   N_MULT_OP N_FACTOR N_MULT_OP_LST
    {
        printRule("MULT_OP_LST", "MULT_OP FACTOR MULT_OP_LST");
    }
    ;
N_FACTOR    :   N_SIGN N_VAR
    {
        printRule("FACTOR", "SIGN VAR");
    }
            |   N_CONST
    {
        printRule("FACTOR", "CONST");
    }
            |   T_LPAREN N_EXPR T_RPAREN
    {
        printRule("FACTOR", "( EXPR )");
    }
            |   T_NOT N_FACTOR
    {
        printRule("FACTOR", "not FACTOR");
    }
    ;
N_SIGN  :   //Epsilon
    {
        printRule("SIGN", "epsilon");
    }
        |   T_PLUS
    {
        printRule("SIGN", "+");
    }
        |   T_MINUS
    {
        printRule("SIGN", "-");
    }
    ;
N_ADD_OP    :   T_PLUS
    {
        printRule("ADD_OP", "+");
    }
            |   T_MINUS
    {
        printRule("ADD_OP", "-");
    }
            |   T_OR
    {
        printRule("ADD_OP", "or");
    }
    ;
N_MULT_OP   :   T_MULT
    {
        printRule("MULT_OP", "*");
    }
            |   T_DIV
    {
        printRule("MULT_OP", "/");
    }
            |   T_AND
    {
        printRule("MULT_OP", "and");
    }
    ;
N_REL_OP    :   T_LT
    {
        printRule("REL_OP", "<");
    }
            |   T_GT
    {
        printRule("REL_OP", ">");
    }
            |   T_LE
    {
        printRule("REL_OP", "<=");
    }
            |   T_GE
    {
        printRule("REL_OP", ">=");
    }
            |   T_EQ
    {
        printRule("REL_OP", "=");
    }
    ;
N_VAR   :   N_ENTIRE_VAR
    {
        printRule("VAR", "ENTIRE_VAR");
    }
        |   N_IDX_VAR
    {
        printRule("VAR", "IDX_VAR");
    }
    ;
N_IDX_VAR   :   N_ARRAY_VAR T_LBRACK N_EXPR T_RBRACK
    {
        printRule("IDX_VAR", "ARRAY_VAR ( EXPR )");
    }
    ;
N_ARRAY_VAR :   N_ENTIRE_VAR
    {
        printRule("ARRAY_VAR", "ENTIRE_VAR");
    }
    ;
N_ENTIRE_VAR    :   N_VAR_IDENT
    {
        printRule("ENTIRE_VAR", "VAR_IDENT");
    }
    ;
N_VAR_IDENT :   T_IDENT
    {
        printRule("VAR_IDENT", "IDENT");
    }
    ;
N_CONST :   N_INTCONST
    {
        printRule("CONST", "INTCONST");
    }
        |   T_CHARCONST
    {
        printRule("CONST", "CHARCONST");
    }
        |   N_BOOLCONST
    {
        printRule("CONST", "BOOLCONST");
    }
    ;
N_INTCONST  :   N_SIGN T_INTCONST
    {
        printRule("INTCONST", "SIGN intconst");
    }
    ;
N_BOOLCONST :   T_TRUE
    {
        printRule("BOOLCONST", "true");
    }
            |   T_FALSE
    {
        printRule("BOOLCONST", "false");
    }
    ;
%%

#include "lex.yy.c"
extern FILE *yyin;

void printRule(const char *lhs, const char *rhs) {
    printf("%s -> %s\n", lhs, rhs);
    return;
}

int yyerror(const char *s) {
    printf("%s\n", s);
    return(1);
}

void printTokenInfo(const char* tokenType, const char* lexeme) {
    printf("TOKEN: %s LEXEME: %s\n", tokenType, lexeme);
}

int main() {
    do {
        yyparse();
    } while (!feof(yyin));

    printf("%d lines processed\n", numLines);

    return 0;
}