Блог

 %union{
    int ival;
    int *ivals;
    char id[20];
    char *str;
}
%start START

%token COMMENT OP_PLUS OP_MINUS OP_DIV OP_MULT OP_OP OP_CP OP_DBLMULT OP_OC OP_CC OP_COMMA KW_AND KW_OR KW_NOT KW_EQUAL KW_LESS
KW_NIL KW_LIST KW_APPEND KW_CONCAT KW_SET KW_DEFFUN KW_FOR KW_IF KW_EXIT KW_DEFVAR KW_WHILE
KW_LOAD KW_DISP KW_TRUE KW_FALSE NEWLINE
FLOAT_NUMBER LISTOP


%token <ival> LIMITED_VALUE
%token <id> IDENTIFIER
%token <str> FLE
%token <ival> NUMBER

%type <ival> START
%type <ival> EXPI
%type <ival> EXPB
%type <ivals> VALUES
%type <ivals> EXPLISTI
%type <ivals> LISTVALUE
%type <ival> BinaryValue

/* Rule Section */
%%     

START:| INPUT{
            if(!flag amp;amp; list_flag){
                printf("Syntax OK.n");
                printf("Result:"); 
                
                printList(listValues,listIndex); 
                listIndex=0;
                
                holdIndex=0;
                list_flag=0;
            }
            else if(!flag amp;amp; binary_flag){
                printf("Syntax OK.n");
                if($==1)
                    printf("Result:Tn");
                else
                    printf("Result:NILn");
                binary_flag=0;
            }
            else if(!flag){
                printf("Syntax OK.n");
                printf("Result:%d",$); 
            }
            return 0;
            };
    
    INPUT: EXPI | EXPLISTI | EXPB{ binary_flag=1; }
    ;
    
    EXPI: OP_OP KW_DEFVAR IDENTIFIER EXPI OP_CP { $=$4; } 
    | OP_OP KW_SET IDENTIFIER EXPI OP_CP { $=$4; } 
    | OP_OP OP_PLUS EXPI EXPI OP_CP { $=$3 $4; } 
    | OP_OP OP_MINUS EXPI EXPI OP_CP { $=$3-$4; } 
    | OP_OP OP_MULT EXPI EXPI OP_CP { $=$3*$4; }
    | OP_OP OP_DIV EXPI EXPI OP_CP { $=$3/$4; } 
 

Это в моем коде .y. Если я написал (* 5 2) в consol, я получаю ошибку, которая является выражением SYNTAX_ERROR, которое не распознается.
Я определил этот синтаксис, почему я получаю такую ошибку? Кроме того, я получил ошибки других определенных синтаксисов, таких как ( 5 2), (/ 5 5)… В чем причина такой ошибки?

—Обновление— in .l код:

 %{ 
    #include<stdio.h> 
    #include<math.h>
    #include "y.tab.h" 
    extern YYSTYPE yylval;

    int c_count = 0; // for open " and close "
%}
COMMENT ";;".*
LIMITED_VALUE [0-9]|[1-9][0-9]*
IDENTIFIER [a-zA-Z][a-zA-Z0-9]*
FLE ["](.*?)["]

and         "and"
or          "or"
not         "not"
equal       "equal"
less        "less"
nil         "nil"
list        "list"
append      "append"
concat      "concat"
set         "set"
deffun      "deffun"
deffvar     "defvar"
for         "for"
while       "while"
if          "if"
exit        "exit"
load        "load"
disp        "disp"
true        "true"
false       "false"


%%

{COMMENT} { return COMMENT; }
and { return KW_AND; }
or { return KW_OR; }
not { return KW_NOT; }
equal { return KW_EQUAL; }
less { return KW_LESS; }
nil { return KW_NIL; }
list { return KW_LIST; }
append { return KW_APPEND; }
concat { return KW_CONCAT; }
set { return KW_SET; }
deffun { return KW_DEFFUN; }
defvar { return KW_DEFVAR; }
for { return KW_FOR; }
while { return KW_WHILE; }
if { return KW_IF; }
exit { return KW_EXIT; }
load { return KW_LOAD; }
disp { return KW_DISP; }
true { return KW_TRUE; }
false { return KW_FALSE; }
"'(" { return LISTOP; }
" " { return OP_PLUS; }
"-" { return OP_MINUS; }
"/" { return OP_DIV; }
"*" { return OP_MULT; }
"(" { return OP_OP; }
")" { return OP_CP;}
"**" { return OP_DBLMULT; }
""" {if(!c_count%2)
        return OP_OC;
    else
        return OP_CC;
      c_count;}
"," { return OP_COMMA; }



[[:alpha:]][[:alnum:]]*   {strcpy(yylval.id, yytext); return IDENTIFIER;}
[[1-9][:digit:]]          {yylval.ival = atoi(yytext); return LIMITED_VALUE;}
{LIMITED_VALUE}                   { yylval.ival = atoi(yytext); return LIMITED_VALUE;}

" "|"t" { } 
"n" {printf("%sn",yytext); return 0; }
.    {printf("SYNTAX ERROR %s IS NOT RECOGNIZED",yytext); return 0;} 
%%

int yywrap() 
{ 
return 1; 
} 
 

весь мой код в этом .l выглядит так.

 When I try to debug:
Starting parse
Entering state 0
Reading a token: >(* 5 2)
Next token is token OP_OP ()
Shifting token OP_OP ()
Entering state 2
Reading a token: Next token is token OP_MULT ()
Shifting token OP_MULT ()
Entering state 19
Reading a token: Next token is token LIMITED_VALUE ()

SYNTAX_ERROR Expression not recognized
Error: popping token OP_MULT ()
Stack now 0 2
Error: popping token OP_OP ()
Stack now 0
Cleanup: discarding lookahead token LIMITED_VALUE ()
Stack now 0