私が望んでいたYaccルールは縮小しません

Question

私のルールでは削減できない問題があります。まず、私は文を検出するために、Yaccのルールを書きたい：

STUDENT_T* pSearch=pHead; 

だから私は以下のようにルールを書いた：

struct_initialize: IDENTIFIER '*' IDENTIFIER '=' IDENTIFIER ';'; 

をその後、私は以下のようにルールにstruct_initializeを置く：

struct_declaration 
: struct_initialize 
| specifier_qualifier_list ';' /* for anonymous struct/union */ {printf("29\n");} 
| specifier_qualifier_list struct_declarator_list ';' {printf("30\n");} 
| static_assert_declaration {printf("31\n");} 
; 

マイフルYaccのファイルは以下の通りです：

%token IDENTIFIER I_CONSTANT F_CONSTANT STRING_LITERAL FUNC_NAME SIZEOF 
%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP 
%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN 
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN 
%token XOR_ASSIGN OR_ASSIGN 
%token TYPEDEF_NAME ENUMERATION_CONSTANT 

%token TYPEDEF EXTERN STATIC AUTO REGISTER INLINE 
%token CONST RESTRICT VOLATILE 
%token BOOL CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE VOID 
%token COMPLEX IMAGINARY 
%token STRUCT UNION ENUM ELLIPSIS 

%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN 

%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATIC_ASSERT THREAD_LOCAL 

%token INCLUDE 


%start translation_unit 
%{ 

    #include<stdio.h> 
    #include<string.h> 
    extern FILE* yyin; 
int yylex(); 
void yyerror(const char *s); 

%} 
%union{ 
    char* a; 
    char* b; 
} 

/*%type <a>IDENTIFIER 
*%type <a>SIGNED UNSIGNED 
*%type <a>INT CHAR DOUBLE FLOAT LONG SHORT 
*%type <b>EXTERN STATIC AUTO REGISTER*/ 

%% 

include 
: '#' INCLUDE '<' IDENTIFIER '.' IDENTIFIER '>' 
| '#' INCLUDE STRING_LITERAL 
; 

struct_initialize 
: IDENTIFIER '*' IDENTIFIER '=' IDENTIFIER ';' 
; 



primary_expression 
: IDENTIFIER {printf("1\n");} 
| constant 
| string 
| '(' expression ')' 
| generic_selection 
; 

constant 
: I_CONSTANT  /* includes character_constant */ {printf("2\n");} 
| F_CONSTANT 
| ENUMERATION_CONSTANT /* after it has been defined as such */ 
; 

enumeration_constant  /* before it has been defined as such */ 
: IDENTIFIER {printf("3\n");} 
; 

string 
: STRING_LITERAL 
| FUNC_NAME 
; 

generic_selection 
: GENERIC '(' assignment_expression ',' generic_assoc_list ')' 
; 

generic_assoc_list 
: generic_association 
| generic_assoc_list ',' generic_association 
; 

generic_association 
: type_name ':' assignment_expression 
| DEFAULT ':' assignment_expression 
; 

postfix_expression 
: primary_expression {printf("59\n");} 
| postfix_expression '[' expression ']' {printf("60\n");} 
| postfix_expression '(' ')' {printf("61\n");} 
| postfix_expression '(' argument_expression_list ')' {printf("62\n");} 
| postfix_expression '.' IDENTIFIER {printf("63\n");} 
| postfix_expression PTR_OP IDENTIFIER {printf("64\n");} 
| postfix_expression INC_OP 
| postfix_expression DEC_OP 
| '(' type_name ')' '{' initializer_list '}' {printf("65\n");} 
| '(' type_name ')' '{' initializer_list ',' '}' {printf("66\n");} 
; 

argument_expression_list 
: assignment_expression 
| argument_expression_list ',' assignment_expression 
; 

unary_expression 
: postfix_expression {printf("67\n");} 
| INC_OP unary_expression 
| DEC_OP unary_expression 
| unary_operator cast_expression {printf("71\n");} 
| SIZEOF unary_expression 
| SIZEOF '(' type_name ')' 
| ALIGNOF '(' type_name ')' 
; 

unary_operator 
: '&' 
| '*' 
| '+' 
| '-' 
| '~' 
| '!' 
; 

cast_expression 
: unary_expression {printf("68\n");} 
| '(' type_name ')' cast_expression {printf("69\n");} 
; 

multiplicative_expression 
: cast_expression {printf("70\n");} 
| multiplicative_expression '*' cast_expression 
| multiplicative_expression '/' cast_expression 
| multiplicative_expression '%' cast_expression 
; 

additive_expression 
: multiplicative_expression {printf("71\n");} 
| additive_expression '+' multiplicative_expression 
| additive_expression '-' multiplicative_expression 
; 

shift_expression 
: additive_expression {printf("72\n");} 
| shift_expression LEFT_OP additive_expression 
| shift_expression RIGHT_OP additive_expression 
; 

relational_expression 
: shift_expression {printf("73\n");} 
| relational_expression '<' shift_expression 
| relational_expression '>' shift_expression 
| relational_expression LE_OP shift_expression 
| relational_expression GE_OP shift_expression 
; 

equality_expression 
: relational_expression {printf("74\n");} 
| equality_expression EQ_OP relational_expression 
| equality_expression NE_OP relational_expression 
; 

and_expression 
: equality_expression {printf("75\n");} 
| and_expression '&' equality_expression 
; 

exclusive_or_expression 
: and_expression {printf("76\n");} 
| exclusive_or_expression '^' and_expression 
; 

inclusive_or_expression 
: exclusive_or_expression {printf("77\n");} 
| inclusive_or_expression '|' exclusive_or_expression 
; 

logical_and_expression 
: inclusive_or_expression {printf("78\n");} 
| logical_and_expression AND_OP inclusive_or_expression 
; 

logical_or_expression 
: logical_and_expression {printf("79\n");} 
| logical_or_expression OR_OP logical_and_expression 
; 

conditional_expression 
: logical_or_expression {printf("80\n");} 
| logical_or_expression '?' expression ':' conditional_expression 
; 

assignment_expression 
: conditional_expression {printf("81\n");} 
| unary_expression assignment_operator assignment_expression {printf("69\n");} 
; 

assignment_operator 
: '=' 
| MUL_ASSIGN 
| DIV_ASSIGN 
| MOD_ASSIGN 
| ADD_ASSIGN 
| SUB_ASSIGN 
| LEFT_ASSIGN 
| RIGHT_ASSIGN 
| AND_ASSIGN 
| XOR_ASSIGN 
| OR_ASSIGN 
; 

expression 
: assignment_expression {printf("82\n");} 
| expression ',' assignment_expression 
; 

constant_expression 
: conditional_expression /* with constraints */ 
; 

declaration 
: declaration_specifiers ';' /* no rule need*/ {printf("4\n");} 
| declaration_specifiers init_declarator_list ';' /* int a;*/ {printf("5\n");} 
| static_assert_declaration {printf("6\n");} 
; 

declaration_specifiers 
: storage_class_specifier declaration {printf("7\n");} 
| storage_class_specifier    {printf("8\n");} 
| type_specifier declaration_specifiers {printf("9\n");} 
| type_specifier {printf("10\n");} 
| type_qualifier declaration_specifiers{printf("11\n");} 
| type_qualifier {printf("12\n");} 
| function_specifier declaration_specifiers {printf("13\n");} 
| function_specifier {printf("14\n");} 
| alignment_specifier declaration_specifiers {printf("15\n");} 
| alignment_specifier {printf("16\n");} 
; 

init_declarator_list 
: init_declarator {printf("17\n");} 
| init_declarator_list ',' init_declarator {printf("18\n");} 
; 

init_declarator 
: declarator '=' initializer {printf("19\n");} 
| declarator {printf("20\n");} 
; 

storage_class_specifier 
: TYPEDEF /* identifiers must be flagged as TYPEDEF_NAME */ {printf("21\n");} 
| EXTERN 
| STATIC 
| THREAD_LOCAL 
| AUTO 
| REGISTER 
; 

type_specifier 
: VOID 
| CHAR 
| SHORT 
| INT 
| LONG 
| FLOAT 
| DOUBLE 
| SIGNED 
| UNSIGNED 
| BOOL 
| COMPLEX 
| IMAGINARY  /* non-mandated extension */ 
| atomic_type_specifier 
| struct_or_union_specifier 
| enum_specifier 
| TYPEDEF_NAME  /* after it has been defined as such */ {printf("22\n");} 
; 



struct_or_union_specifier 
: struct_or_union '{' struct_declaration_list '}' {printf("23\n");} 
| struct_or_union IDENTIFIER '{' struct_declaration_list '}' {printf("24\n");} 
| struct_or_union IDENTIFIER {printf("25\n");} 
; 

struct_or_union 
: STRUCT 
| UNION 
; 

struct_declaration_list 
: struct_declaration {printf("26\n");} 
| struct_declaration_list struct_declaration {printf("27\n");} 
; 

struct_declaration 
: struct_initialize 
| specifier_qualifier_list ';' /* for anonymous struct/union */ {printf("29\n");} 
| specifier_qualifier_list struct_declarator_list ';' {printf("30\n");} 
| static_assert_declaration {printf("31\n");} 
; 

specifier_qualifier_list 
: type_specifier specifier_qualifier_list {printf("32\n");} 
| type_specifier {printf("33\n");} 
| type_qualifier specifier_qualifier_list {printf("34\n");} 
| type_qualifier {printf("35\n");} 
; 

struct_declarator_list 
: struct_declarator {printf("36\n");} 
| struct_declarator_list ',' struct_declarator {printf("37\n");} 
; 

struct_declarator 
: ':' constant_expression {printf("38\n");} 
| declarator ':' constant_expression {printf("39\n");} 
| declarator {printf("40\n");} 
; 

enum_specifier 
: ENUM '{' enumerator_list '}' 
| ENUM '{' enumerator_list ',' '}' 
| ENUM IDENTIFIER '{' enumerator_list '}' 
| ENUM IDENTIFIER '{' enumerator_list ',' '}' 
| ENUM IDENTIFIER 
; 

enumerator_list 
: enumerator 
| enumerator_list ',' enumerator 
; 

enumerator /* identifiers must be flagged as ENUMERATION_CONSTANT */ 
: enumeration_constant '=' constant_expression 
| enumeration_constant 
; 

atomic_type_specifier 
: ATOMIC '(' type_name ')' 
; 

type_qualifier 
: CONST 
| RESTRICT 
| VOLATILE 
| ATOMIC 
; 

function_specifier 
: INLINE 
| NORETURN 
; 

alignment_specifier 
: ALIGNAS '(' type_name ')' 
| ALIGNAS '(' constant_expression ')' 
; 

declarator 
: pointer direct_declarator 
| direct_declarator 
; 

direct_declarator 
: IDENTIFIER {printf("41\n");} 
| '(' declarator ')' {printf("42\n");} 
| direct_declarator '[' ']' {printf("43\n");} 
| direct_declarator '[' '*' ']' {printf("44\n");} 
| direct_declarator '[' STATIC type_qualifier_list assignment_expression ']' {printf("45\n");} 
| direct_declarator '[' STATIC assignment_expression ']' {printf("46\n");} 
| direct_declarator '[' type_qualifier_list '*' ']' 
| direct_declarator '[' type_qualifier_list STATIC assignment_expression ']' 
| direct_declarator '[' type_qualifier_list assignment_expression ']' 
| direct_declarator '[' type_qualifier_list ']' {printf("47\n");} 
| direct_declarator '[' assignment_expression ']' {printf("48\n");} 
| direct_declarator '(' parameter_type_list ')' {printf("49\n");} 
| direct_declarator '(' ')' {printf("50\n");} 
| direct_declarator '(' identifier_list ')' {printf("51\n");} 
; 

pointer 
: '*' type_qualifier_list pointer 
| '*' type_qualifier_list 
| '*' pointer 
| '*' 
; 

type_qualifier_list 
: type_qualifier {printf("52\n");} 
| type_qualifier_list type_qualifier {printf("53\n");} 
; 


parameter_type_list 
: parameter_list ',' ELLIPSIS 
| parameter_list 
; 

parameter_list 
: parameter_declaration 
| parameter_list ',' parameter_declaration 
; 

parameter_declaration 
: declaration_specifiers declarator 
| declaration_specifiers abstract_declarator 
| declaration_specifiers 
; 

identifier_list 
: IDENTIFIER 
| identifier_list ',' IDENTIFIER 
; 

type_name 
: specifier_qualifier_list abstract_declarator 
| specifier_qualifier_list 
; 

abstract_declarator 
: pointer direct_abstract_declarator 
| pointer 
| direct_abstract_declarator 
; 

direct_abstract_declarator 
: '(' abstract_declarator ')' 
| '[' ']' 
| '[' '*' ']' 
| '[' STATIC type_qualifier_list assignment_expression ']' 
| '[' STATIC assignment_expression ']' 
| '[' type_qualifier_list STATIC assignment_expression ']' 
| '[' type_qualifier_list assignment_expression ']' 
| '[' type_qualifier_list ']' 
| '[' assignment_expression ']' 
| direct_abstract_declarator '[' ']' 
| direct_abstract_declarator '[' '*' ']' 
| direct_abstract_declarator '[' STATIC type_qualifier_list assignment_expression ']' 
| direct_abstract_declarator '[' STATIC assignment_expression ']' 
| direct_abstract_declarator '[' type_qualifier_list assignment_expression ']' 
| direct_abstract_declarator '[' type_qualifier_list STATIC assignment_expression ']' 
| direct_abstract_declarator '[' type_qualifier_list ']' 
| direct_abstract_declarator '[' assignment_expression ']' 
| '(' ')' 
| '(' parameter_type_list ')' 
| direct_abstract_declarator '(' ')' 
| direct_abstract_declarator '(' parameter_type_list ')' 
; 

initializer 
: '{' initializer_list '}' 
| '{' initializer_list ',' '}' 
| assignment_expression {printf("83\n");} 
; 

initializer_list 
: designation initializer 
| initializer 
| initializer_list ',' designation initializer 
| initializer_list ',' initializer 
; 

designation 
: designator_list '=' {printf("54\n");} 
; 

designator_list 
: designator {printf("55\n");} 
| designator_list designator {printf("56\n");} 
; 

designator 
: '[' constant_expression ']' 
| '.' IDENTIFIER 
; 

static_assert_declaration 
: STATIC_ASSERT '(' constant_expression ',' STRING_LITERAL ')' ';' 
; 

statement 
: labeled_statement 
| compound_statement 
| expression_statement 
| selection_statement 
| iteration_statement 
| jump_statement 
; 

labeled_statement 
: IDENTIFIER ':' statement 
| CASE constant_expression ':' statement 
| DEFAULT ':' statement 
; 

compound_statement 
: '{' '}' 
| '{' block_item_list '}' 
; 

block_item_list 
: block_item 
| block_item_list block_item 
; 

block_item 
: declaration 
| statement 
; 

expression_statement 
: ';' 
| expression ';' 
; 

selection_statement 
: IF '(' expression ')' statement ELSE statement 
| IF '(' expression ')' statement 
| SWITCH '(' expression ')' statement 
; 

iteration_statement 
: WHILE '(' expression ')' statement 
| DO statement WHILE '(' expression ')' ';' 
| FOR '(' expression_statement expression_statement ')' statement 
| FOR '(' expression_statement expression_statement expression ')' statement 
| FOR '(' declaration expression_statement ')' statement 
| FOR '(' declaration expression_statement expression ')' statement 
; 

jump_statement 
: GOTO IDENTIFIER ';' 
| CONTINUE ';' 
| BREAK ';' 
| RETURN ';' 
| RETURN expression ';' 
; 

translation_unit 
: external_declaration 
| translation_unit external_declaration 
; 

external_declaration 
: function_definition 
| declaration 
| include /********/ 
; 

function_definition 
: declaration_specifiers declarator declaration_list compound_statement 
| declaration_specifiers declarator compound_statement 
; 

declaration_list 
: declaration {printf("57\n");} 
| declaration_list declaration {printf("58\n");} 
; 

%% 
#include <stdio.h> 

void yyerror(const char *s) 
{ 
    fflush(stdout); 
    fprintf(stderr, "*** %s\n", s); 
} 
void parse(FILE* fileInput) 
{ 
    yyin= fileInput; 
    while(feof(yyin)==0) 
    { 
     yyparse();// To read file, while() and yyparse() is necessary because we need to read until the content is run out 
    } 
} 

この対応さレックスコード：それは声明を読ん

%e 1019 
%p 2807 
%n 371 
%k 284 
%a 1213 
%o 1117 

Q \" 
O [0-7] 
D [0-9] 
NZ [1-9] 
L [a-zA-Z_] 
A [a-zA-Z_0-9] 
H [a-fA-F0-9] 
HP (0[xX]) 
E ([Ee][+-]?{D}+) 
P ([Pp][+-]?{D}+) 
FS (f|F|l|L) 
IS (((u|U)(l|L|ll|LL)?)|((l|L|ll|LL)(u|U)?)) 
CP (u|U|L) 
SP (u8|u|U|L) 
ES (\\(['"\?\\abfnrtv]|[0-7]{1,3}|x[a-fA-F0-9]+)) 
WS [ \t\v\n\f] 

%{ 
    #include <stdio.h> 
    #include "y.tab.h" 

    extern void yyerror(const char *); /* prints grammar violation message */ 

    extern int sym_type(const char *); /* returns type from symbol table */ 

    #define sym_type(identifier) IDENTIFIER /* with no symbol table, fake it */ 

    static void comment(void); 
    static int check_type(void); 
%} 

%% 


"/*"         { comment(); } 
"//".*         { /* consume //-comment */ } 

"include"    { yylval.a=strdup(yytext); return(INCLUDE); } 
"void"     { yylval.a=strdup(yytext); return(VOID); } 
"int"     { yylval.a=strdup(yytext); return(INT); } /* Data Type*/ 
"long"     { yylval.a=strdup(yytext); return(LONG); } 
"char"     { yylval.a=strdup(yytext); return(CHAR); } 
"short"     { yylval.a=strdup(yytext); return(SHORT); } 
"signed"    { yylval.a=strdup(yytext); return(SIGNED); } 
"double"    { yylval.a=strdup(yytext); return(DOUBLE); } 
"unsigned"    { yylval.a=strdup(yytext); return(UNSIGNED); } 
"float"     { yylval.a=strdup(yytext); return(FLOAT); } 


"auto"     { yylval.a=strdup(yytext); return(AUTO); } /*Storage Class*/ 
"extern"    { yylval.a=strdup(yytext); return(EXTERN); } 
"register"    { yylval.a=strdup(yytext); return(REGISTER); } 
"static"    { yylval.a=strdup(yytext); return(STATIC); } 


"const"     { yylval.a=strdup(yytext); return(CONST); } /*Type Qualifier*/ 
"restrict"    { yylval.a=strdup(yytext); return(RESTRICT); } 
"volatile"    { yylval.a=strdup(yytext); return(VOLATILE); } 
"_Atomic"    { yylval.a=strdup(yytext); return ATOMIC; } 


"break"     { yylval.a=strdup(yytext); return(BREAK); } 
"case"     { yylval.a=strdup(yytext); return(CASE); } 

"continue"    { yylval.a=strdup(yytext); return(CONTINUE); } 
"default"    { yylval.a=strdup(yytext); return(DEFAULT); } 
"do"     { yylval.a=strdup(yytext); return(DO); } 
"else"     { yylval.a=strdup(yytext); return(ELSE); } 
"enum"     { yylval.a=strdup(yytext); return(ENUM); } 

"for"     { yylval.a=strdup(yytext); return(FOR); } 
"goto"     { yylval.a=strdup(yytext); return(GOTO); } 
"if"     { yylval.a=strdup(yytext); return(IF); } 
"inline"    { yylval.a=strdup(yytext); return(INLINE); } 


"return"    { yylval.a=strdup(yytext); return(RETURN); } 
"sizeof"    { yylval.a=strdup(yytext); return(SIZEOF); } 

"struct"    { yylval.a=strdup(yytext); return(STRUCT); } 
"switch"    { yylval.a=strdup(yytext); return(SWITCH); } 
"typedef"    { yylval.a=strdup(yytext); return(TYPEDEF); } 
"union"     { yylval.a=strdup(yytext); return(UNION); } 



"while"     { yylval.a=strdup(yytext); return(WHILE); } 
"_Alignas"    { yylval.a=strdup(yytext); return ALIGNAS; } 
"_Alignof"    { yylval.a=strdup(yytext); return ALIGNOF; } 

"_Bool"     { yylval.a=strdup(yytext); return BOOL; } 
"_Complex"    { yylval.a=strdup(yytext); return COMPLEX; } 
"_Generic"    { yylval.a=strdup(yytext); return GENERIC; } 
"_Imaginary"   { yylval.a=strdup(yytext); return IMAGINARY; } 
"_Noreturn"    { yylval.a=strdup(yytext); return NORETURN; } 
"_Static_assert"  { yylval.a=strdup(yytext); return STATIC_ASSERT; } 
"_Thread_local"   { yylval.a=strdup(yytext); return THREAD_LOCAL; } 
"__func__"    { yylval.a=strdup(yytext); return FUNC_NAME; } 

{Q}      { yylval.a=strdup(yytext); return'"'; } 
"..."     { yylval.a=strdup(yytext); return ELLIPSIS; } 
">>="     { yylval.a=strdup(yytext); return RIGHT_ASSIGN; } 
"<<="     { yylval.a=strdup(yytext); return LEFT_ASSIGN; } 
"+="     { yylval.a=strdup(yytext); return ADD_ASSIGN; } 
"-="     { yylval.a=strdup(yytext); return SUB_ASSIGN; } 
"*="     { yylval.a=strdup(yytext); return MUL_ASSIGN; } 
"/="     { yylval.a=strdup(yytext); return DIV_ASSIGN; } 
"%="     { yylval.a=strdup(yytext); return MOD_ASSIGN; } 
"&="     { yylval.a=strdup(yytext); return AND_ASSIGN; } 
"^="     { yylval.a=strdup(yytext); return XOR_ASSIGN; } 
"|="     { yylval.a=strdup(yytext); return OR_ASSIGN; } 
">>"     { yylval.a=strdup(yytext); return RIGHT_OP; } 
"<<"     { yylval.a=strdup(yytext); return LEFT_OP; } 
"++"     { yylval.a=strdup(yytext); return INC_OP; } 
"--"     { yylval.a=strdup(yytext); return DEC_OP; } 
"->"     { yylval.a=strdup(yytext); return PTR_OP; } 
"&&"     { yylval.a=strdup(yytext); return AND_OP; } 
"||"     { yylval.a=strdup(yytext); return OR_OP; } 
"<="     { yylval.a=strdup(yytext); return LE_OP; } 
">="     { yylval.a=strdup(yytext); return GE_OP; } 
"=="     { yylval.a=strdup(yytext); return EQ_OP; } 
"!="     { yylval.a=strdup(yytext); return NE_OP; } 
";"      { yylval.a=strdup(yytext); return ';'; } 
("{"|"<%")    { yylval.a=strdup(yytext); return '{'; } 
("}"|"%>")    { yylval.a=strdup(yytext); return '}'; } 
","      { yylval.a=strdup(yytext); return ','; } 
":"      { yylval.a=strdup(yytext); return ':'; } 
"="      { yylval.a=strdup(yytext); return '='; } 
"("      { yylval.a=strdup(yytext); return '('; } 
")"      { yylval.a=strdup(yytext); return ')'; } 
("["|"<:")    { yylval.a=strdup(yytext); return '['; } 
("]"|":>")    { yylval.a=strdup(yytext); return ']'; } 
"."      { yylval.a=strdup(yytext); return '.'; } 
"&"      { yylval.a=strdup(yytext); return '&'; } 
"!"      { yylval.a=strdup(yytext); return '!'; } 
"~"      { yylval.a=strdup(yytext); return '~'; } 
"-"      { yylval.a=strdup(yytext); return '-'; } 
"+"      { yylval.a=strdup(yytext); return '+'; } 
"*"      { yylval.a=strdup(yytext); return '*'; } 
"/"      { yylval.a=strdup(yytext); return '/'; } 
"%"      { yylval.a=strdup(yytext); return '%'; } 
"<"      { yylval.a=strdup(yytext); return '<'; } 
">"      { yylval.a=strdup(yytext); return '>'; } 
"^"      { yylval.a=strdup(yytext); return '^'; } 
"|"      { yylval.a=strdup(yytext); return '|'; } 
"?"      { yylval.a=strdup(yytext); return '?'; } 
"#"      { yylval.a=strdup(yytext); return '#'; } 

{L}{A}*     { return check_type(); } 

{HP}{H}+{IS}?    { yylval.a=strdup(yytext); return I_CONSTANT; } 
{NZ}{D}*{IS}?    { yylval.a=strdup(yytext); return I_CONSTANT; } 
"0"{O}*{IS}?    { yylval.a=strdup(yytext); return I_CONSTANT; } 
{CP}?"'"([^'\\\n]|{ES})+"'"  { return I_CONSTANT; } /**/ 

{D}+{E}{FS}?    { yylval.a=strdup(yytext); return F_CONSTANT; } 
{D}*"."{D}+{E}?{FS}?  { yylval.a=strdup(yytext); return F_CONSTANT; } 
{D}+"."{E}?{FS}?   { yylval.a=strdup(yytext); return F_CONSTANT; } 
{HP}{H}+{P}{FS}?   { yylval.a=strdup(yytext);return F_CONSTANT; } 
{HP}{H}*"."{H}+{P}{FS}?  { yylval.a=strdup(yytext); return F_CONSTANT; } 
{HP}{H}+"."{P}{FS}?   { yylval.a=strdup(yytext); return F_CONSTANT; } 

({SP}?\"([^"\\\n]|{ES})*\"{WS}*)+ { return STRING_LITERAL; } 


{WS}+     { /* whitespace separates tokens */ } 

.     { /* discard bad characters */ } 

%% 

int yywrap(void)  /* called at end of input */ 
{ 
    return 1;   /* terminate now */ 
} 

static void comment(void) 
{ 
    int c; 

    while ((c = input()) != 0) 
    if (c == '*') 
    { 
     printf("1: %d\n",c); 
     while ((c = input()) == '*') 
     ; 
     printf("2: %d\n",c); 
     if (c == '/') 
     return; 
     if (c == 0) 
     printf("3: %d\n",c); 
     break; 
    } 
    yyerror("unterminated comment"); 
} 

static int check_type(void) 
{ 
    switch (sym_type(yytext)) 
    { 
     case TYPEDEF_NAME:    /* previously defined */ 
      { 
       printf("TYPEDEF_NAME\n"); 
      return TYPEDEF_NAME; 
      } 
     case ENUMERATION_CONSTANT:  /* previously defined */ 
      { 
      printf("ENUMERATION\n"); 
      return ENUMERATION_CONSTANT; 
      } 
     default:       /* includes undefined */ /*This is when do normal declaration such as int a=3; in this case it return a*/ 
      { 
      printf("IDENTIFIER\n"); 
      yylval.a=strdup(yytext); 
      return IDENTIFIER; 
      } 
    } 
} 

：STUDENT_T* pSearch=pHead;出力は次のとおりです。私はデバッグのために数1-80のように文字列リテラルとprintfを使用

--accepting rule at line 156 ("STUDENT_T") 
IDENTIFIER 
--accepting rule at line 146 ("*") 
1 
59 
67 
68 
70 
--accepting rule at line 173 (" ") 
--accepting rule at line 156 ("pSearch") 
IDENTIFIER 
1 
59 
--accepting rule at line 135 ("=") 
67 
68 
71 
72 
73 
74 
75 
76 
77 
78 
79 
80 
81 
82 
*** syntax error 

注意Yaccファイルに保存します。 私が間違っていた箇所や修正方法を教えてください。それはトークン化されているとしてだけ

STUDENT_T* pSearch=pHead; 

からなる

Answer 1

テキストは、あなたが提示してきた文法では有効ではありません。

あなたのレクサーは最初のトークンとしてSTUDENT_Tと一致しています。これは問題ありません。それは文脈の中で妥当と思われるIDENTIFIERとしてそれを分類しています。しかしその時点であなたは死んでいます：IDENTIFIERで始まるあなたの文法に従ったテキストはありません。 struct_initializeプロダクションがあなたのトークンシーケンスと一致することができないという事実は、パーサーがそのシンボルへの入力全体を減らしたとしても残りの部分をtranslation_unit開始シンボルに還元することができないためです。何が価値があるために

、 は私の yacc（1.9 byaccには）パーサを放出するとすぐにエラーが出て、それは私の bison（V2.7）ないので、最初のトークンとして IDENTIFIERを見て、と。 yaccは、あなたが指定した入力に対して実際に動作している場合、希望がないことを認識する前に、より多くの機能を果たすパーサを提供するのは少し驚くべきことです。しかし、周囲のどのような方法でも、パーサーが間違った結果を出すと思う理由はありません。

---

あなたの文法でより深く見ると、struct_initializeが表示されることができる唯一の場所は、それがstruct_declarationとしての役割を果たすことができる場所です。これは、構造体または共用体宣言の内容であるstruct_declaration_listの一部または全部としてのみ使用されます。

struct { STUDENT_T* pSearch=pHead; }; 

と余分な計装のビットは、パーサがそうすることで、あなたの生産を使用していることを示しています。確かに、このテキストは、あなたの文法から構築されたパーサによって受け入れられています。