Bison未创建y.tab.c文件

我正在做一个项目，在这个项目中，我必须识别亚洲化、算术、逻辑和关系运算符。据我所知，我的.l文件没有问题，但在我的.y中，当我尝试使用YACC时遇到问题，它没有使用命令

bison-yd cy

这是我的.l文件，名为p3.l

%option yylineno

%{
    #include "p3.tab.h"
    int nLinea = 1;
    int lineStart = 0;
    char buffer[1024] = "";
%}

%x STRING COMENTARIOML

DELIMITADORES "{"|"}"|"?"|":"|";"|","|"("|")"

OPERADORESBASICOS "+"|"-"|"*"|"/"|"%"|"."|"&"|"["|"]"|"~"|"|"|"^"|"<"|">"|"!"|"="|"#"|"%"

ENTERO  (0[xX][0-9A-Fa-f]+)|(0[0-7]+)|[0-9]+
REAL    ([0-9]\.?[0-9]+([eE][+-]?[0-9]+)?)|(0[xX][0-9A-Fa-f]\.?[0-9A-Fa-f]+([eE][+-]?[0-9]+)?)
CARACTER    (\'[^\n'\\]\')|(\'\\['"\?\\abfnrtv]\')|(\'\\[0-3]?[0-7]{1,2}\')|(\'\\x[0-9A-Fa-f]{1,2}\')

CIDENTIFICADOR [a-zA-Z\_]
IDENTIFICADOR [a-zA-Z\_0-9]
ESPACIOS (\n|\t|\ )

%%

"char"      { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(CHAR); }
"double"    { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(DOUBLE); }
"else"      { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(ELSE); }
"float"     { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(FLOAT); }
"for"       { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(FOR); }
"if"        { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(IF); } 
"int"       { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(INT); }
"register"  { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(REGISTER); }
"return"    { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(RETURN); }
"struct"    { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(STRUCT); }
"void"      { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(VOID); }
"while"     { printf("(Lexer | Linea %d) Palabra reservada: %s\n", yylineno, yytext); return(WHILE); }

"--"    { printf("(Lexer | Linea %d) Operador: %s\n", yylineno, yytext); return(DMINUS); }
"++"    { printf("(Lexer | Linea %d) Operador: %s\n", yylineno, yytext); return(DPLUS); }

"=="    { printf("(Lexer | Linea %d) Operador: %s\n", yylineno, yytext); return(DEQUAL); }
"+="    { printf("(Lexer | Linea %d) Operador: %s\n", yylineno, yytext); return(PLUSEQUAL); }


{OPERADORESBASICOS} { printf("(Lexer | Linea %d) Operador: %s\n", yylineno, yytext); return(yytext[0]); }

{ENTERO}    { printf("(Lexer | Linea %d) Constante entera: %s\n", yylineno, yytext); return(INTEGER); }
{REAL}      { printf("(Lexer | Linea %d) Constante real: %s\n", yylineno, yytext); return(REAL); }
{CARACTER}  { printf("(Lexer | Linea %d) Carácter: %s\n", yylineno, yytext); return(CHARACTER); }

{ESPACIOS}                          { /* Se ignoran sin más */ }
{DELIMITADORES}                     { printf("(Lexer | Linea %d) Delimitador: %s\n", yylineno, yytext); return(yytext[0]); }
{CIDENTIFICADOR}?{IDENTIFICADOR}*   { printf("(Lexer | Linea %d) Identificador: %s\n", yylineno, yytext); return(IDENTIFIER); }


<COMENTARIOML>.
<COMENTARIOML>\n      { ++nLinea; }
<COMENTARIOML>"*/"    { printf("(Lexer | Linea %d) Comentario ignorado.\n", yylineno); BEGIN(INITIAL); }



\" {
    BEGIN(STRING);
    lineStart = yylineno;
    strncpy(buffer, "\"", 1024);
}

<STRING>[^\"\n"] {
    strcat(buffer, yytext);
}

<STRING>\n {
    ++nLinea;
    strcat(buffer, yytext);;
}

<STRING>\\\" {
    strcat(buffer, yytext);
}

<STRING>\" {
    strcat(buffer, yytext);
    BEGIN(INITIAL);
    printf("(Lexer | Linea %d) Cadena de caracteres: %s \n", lineStart, buffer);
    strncpy(buffer, "", 1024);
    return(CADENA);
}

.   {printf("(Lexer | Linea %d) ERROR: %s\n", yylineno, yytext);}

%%

%yylineno选项
%{
#包括“p3.表h”
int nLinea=1；
int lineStart=0；
字符缓冲区[1024]=“”；
%}
%x字符串COMENTARIOML
定界符“{”|“}”|“？”|“：”|“；”|“；”，“|“（“|”）”
歌剧基础剧“+”|“-“*”|“/”|“%”“|”&“|”[“|”]“|”~“|”|“|”^“|”！“|”=“|”|“|”%”
肠（0[xX][0-9A-Fa-f]+）|（0[0-7]+）|[0-9]+
实数（[0-9]\.？[0-9]+（[eE][+-]？[0-9]+）？）（0[xX][0-9A-Fa-f]\.？[0-9A-Fa-f]+（[eE][+-]？[0-9]+））
字符（\'[^\n'\]\'）\（\'\['\？\\abfnrtv]\'）（\'\[0-3]？[0-7]{1,2}'）（\'\\x[0-9A-Fa-f]{1,2}'）
CIDENTIFICADOR[a-zA-Z\\\
识别器[a-zA-Z\\u 0-9]
ESPACIOS（\n | \t | \）
%%
“char”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（char）；}
“double”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（double）；}
“else”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；return（else）；}
“float”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（float）；}
对于“{printf（（（Lexer | Linea%d）Palabra reservada:%s\n”，yylineno，yytext）；返回（for）；}”
“如果”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（如果）；}”
“int”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（int）；}
“寄存器”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（寄存器）；}”
“return”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；return（return）；}”
“struct”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（struct）；}
“void”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；返回（void）；}
“while”{printf（（（Lexer | Linea%d）Palabra reservada:%s\n），yylineno，yytext）；return（while）；}”
“-”{printf（（（Lexer | Linea%d）Operador:%s\n），yylineno，yytext）；return（DMINUS）；}
“++”{printf（（（Lexer | Linea%d）运算符：%s\n），yylineno，yytext）；返回（DPLUS）；}
“=”{printf（（（Lexer | Linea%d）Operador:%s\n），yylineno，yytext）；返回（DEQUAL）；}
“+=”{printf（（（Lexer | Linea%d）Operador:%s\n），yylineno，yytext）；返回（PLUSEQUAL）；}
{OPERADORESBASICOS}{printf（（（Lexer | Linea%d）Operador:%s\n），yylineno，yytext）；返回（yytext[0]）；}
{ENTERO}{printf（（（Lexer | Linea%d）Constante entera:%s\n），yylineno，yytext）；返回（整数）；}
{REAL}{printf（（（Lexer | Linea%d）Constante REAL:%s\n），yylineno，yytext）；return（REAL）；}
{CARACTER}{printf（（（Lexer | Linea%d）字符：%s\n），yylineno，yytext）；返回（字符）；}
{ESPACIOS}{/*Se ignoran sin más*/}
{diffractadores}{printf（（（Lexer | Linea%d）diffractador:%s\n），yylineno，yytext）；返回（yytext[0]）；}
{CIDENTIFICADOR}？{IDENTIFICADOR}*{printf（（（Lexer | Linea%d）IDENTIFICADOR:%s\n），yylineno，yytext）；返回（标识符）；}
.
\n{++nLinea；}
“*/”{printf（（Lexer | Linea%d）Comentario ignorado.\n“，yylineno）；BEGIN（首字母）；}
\" {
开始（字符串）；
lineStart=yylineno；
strncpy（缓冲区“\”，1024）；
}
[^\“\n”]{
strcat（缓冲区，文本）；
}
\n{
++nLinea；
strcat（缓冲区，文本）；；
}
\\\" {
strcat（缓冲区，文本）；
}
\" {
strcat（缓冲区，文本）；
开始（首字母）；
printf（（（Lexer | Linea%d）字符编号：%s\n），lineStart，buffer）；
strncpy（缓冲区“”，1024）；
返回（卡德纳）；
}
.{printf（（（Lexer | Linea%d）错误：%s\n“，yylineno，yytext）；}
%%

这是我的.y文件，名为p3.y

%{ /* Codigo C */
    #include <stdio.h>
    
%}



/* Declaraciones de BISON */

%union {
    int valor_entero;
    double valor_real;
    char * texto;
}


/* Definición de los TOKENS */

%token <valor_real> REAL
%token <valor_entero> INTEGER
%token <texto> IDENTIFIER CHARACTER CADENA AUTO CHAR DOUBLE ELSE  EXTERN FLOAT FOR IF INT REGISTER RETURN STATIC STRUCT VOID WHILE

/* Definición de la ASOCIATIVIDAD y PRECEDENCIA de los operadores */

%right '=' PLUSEQUAL MINUSEQUAL
%left '<' '>'
%left '-' '+'
%right DMINUS DPLUS
%left ')'
%right '('

%expect 2

%%

/* Gramatica */

/********** BLOQUES ************/

programa : lista_bloques ;

lista_bloques: bloque
|  bloque  lista_bloques ;

bloque : definicion_funcion
| declaracion ;

definicion_funcion : IDENTIFIER bloque_instrucciones
| declaracion_tipo IDENTIFIER bloque_instrucciones ;

constante : INTEGER
| REAL
| CADENA
| CHARACTER ;

/********** DECLARACIONES ************/
declaracion : declaracion_tipo lista_nombres ';'
| declaracion_tipo ';' ;

identificador_list : IDENTIFIER
| IDENTIFIER identificador_list ;

declaracion_tipo: almacenamiento_list  tipo_basico_modificado
| tipo_basico_modificado ;

tipo_basico_modificado :  '[' IDENTIFIER ']'
| tipo_basico ;

almacenamiento : EXTERN
| STATIC
| AUTO
| REGISTER ;

almacenamiento_list : almacenamiento
| almacenamiento almacenamiento_list ;


tipo_basico : VOID
| CHAR
| INT
| FLOAT
| DOUBLE ;

struct_union : STRUCT ;


declaracion_struct_list : declaracion_struct
| declaracion_struct declaracion_struct_list;

declaracion_struct : tipo_basico_modificado lista_nombres ';' ;


lista_nombres : nombre
| nombre ',' lista_nombres ;

nombre : dato
| dato '=' elementos ;

dato : IDENTIFIER
| IDENTIFIER '['']'
| IDENTIFIER '[' expresion ']' ;

elementos : expresion
| '{' elementosLista '}' ;

elementosLista : elementos
| elementos ',' elementosLista ;



/********** EXPRESIONES ************/

expresion : expresion_logica
| expresion '-' expresion
| expresion '+' expresion ;

expresion_logica: expresion '<' expresion
| expresion '<''>' expresion ;


expresion_constante : INTEGER
| REAL
| CADENA
| CHARACTER
| '(' expresion ')' ;


expresion_funcional : IDENTIFIER '(' ')'
| IDENTIFIER '(' lista_expresiones ')' ;

lista_expresiones : expresion
| lista_expresiones ',' expresion ;


expresion_indexada : IDENTIFIER ;

expresion_postfija : expresion_constante
| expresion_funcional
| expresion_indexada
| expresion_postfija DPLUS
| expresion_postfija DMINUS ;

expresion_prefija : expresion_postfija
| DPLUS expresion_prefija
| DMINUS expresion_prefija
| operador_unario expresion_cast ;


operador_unario : '+'
| '-' ;

expresion_cast : expresion_prefija
| '(' nombre_tipo ')' expresion_cast ;

nombre_tipo : tipo_basico_modificado ;





/********** INSTRUCCIONES ************/

instruccion : bloque_instrucciones
| instruccion_expresion
| instruccion_bifurcacion
| instruccion_bucle
| instruccion_retorno ;

bloque_instrucciones : '{' '}'
| '{' declaracion_list '}'
| '{' instruccion_list '}'
| '{' declaracion_list instruccion_list '}' ;

declaracion_list : declaracion
| declaracion declaracion_list ;


instruccion_list : instruccion
| instruccion instruccion_list ;

instruccion_expresion : expresion ';'
| asignacion ';' ;



asignacion : expresion_indexada operador_asignacion expresion ;


operador_asignacion : '='
| PLUSEQUAL
| MINUSEQUAL ;

instruccion_bifurcacion : IF '(' expresion ')' instruccion
| IF '(' expresion ')' instruccion ELSE instruccion ;

instruccion_bucle : WHILE '(' expresion ')' instruccion
| FOR '(' ';' expresion ';' expresion ')' instruccion
| FOR '(' lista_asignaciones ';' expresion ';' expresion ')' instruccion ;

lista_asignaciones : asignacion
| asignacion ',' lista_asignaciones ;

instruccion_retorno : RETURN ';'
| RETURN expresion ';';



%%

int main (int argc, char * argv[ ])
{
    extern FILE * yyin;
    
    if (argc != 2) {
        fprintf(stderr, "USO: %s fichero\n", argv[0]);
        return -1;
    }
    
    yyin = fopen(argv[1], "r");
    if (!yyin) {
        fprintf(stderr, "Fichero inexistente %s\n", argv[1]);
        return -1;
    }
    
    yyparse();
    fclose(yyin);
    
    
    return 1;
    
    
}

yyerror (char *s) { printf ("%s\n", s); }

int yywrap() { return 1; }

%{/*Codigo C*/
#包括
%}
/*野牛宣言*/
%联合{
英特瓦洛尔；
双重勇气；
char*texto；
}
/*代币定义*/
%象征性真实
%令牌整数
%IF INT寄存器的令牌标识符字符CADENA AUTO CHAR DOUBLE ELSE外部浮点值返回静态结构VOID WHILE
/*歌剧演员协会和协会的定义*/
%右“=”加上等号
%左“
%左''''+'
%右DMINUS DPLUS
%左“）”
%对'（'
%期望2
%%
/*禾本科*/
/**********斑点************/
方案A：lista_bloques；
lista_bloque:bloque
|bloque lista_bloques；
bloque：定义函数
|宣言；
定义函数：标识符bloque\u指令
|声明标识符bloque_instruciones；
康斯坦特：整数
|真实的
|卡德纳
|性格；
/**********声明************/
声明：声明
|声明；
标识符或列表：标识符
|标识符标识或列表；
声明：Almacenaminto清单tipo\u basico\u modificado
|tipo_basico_modificado；
tipo_basico_modificado:“[”标识符“]”
|提波乌巴西科；
阿尔马森纳曼托：外星人
|静止的
|自动的
|登记册；
Almacenaminto_名单：Almacenaminto
|阿拉木图阿拉木图列表；
提波乌巴西科：无效
|煤焦
|INT
|浮动
|加倍；
结构联合：结构；
声明结构列表：声明结构
|声明结构声明结构列表；
声明结构：tipo_basico_modificado lista_nombres'；
名称列表：名称
|名称“，”列表名称；
名称：达托
|dato'='元素；
dato：标识符
|标识符'['']'
|标识符“[”表达式“]”；
元素：表达式
|{'elementosLista'}'；
elementosLista:elementos
|“elementos”、“elementosLista”；
/**********表达************/
expresion:expresion_logica
|expresion'-'expresion
|表达式'+'表达式；
expresion_logica:expresion'
它没有使用命令
bison-yd cy

您的文件名为<