Haga preguntas sobre Lex y Yacc en las herramientas de desarrollo del generador de analizadores.
Nota: la expresión es de tipo doble, stringexp es de tipo char *.
Propósito: Implementar el modo de entrada mixto de calculadora y cadena.
Estado: Se han implementado la calculadora simple y la expresión de sintaxis ADD stringexp (por ejemplo: 3+4+"sdfe").
Problema: La combinación del tipo de cadena char * en sí y su combinación con el tipo de calculadora doble, es decir, la sintaxis de expresión stringexp ADD stringexp y stringexp ADD no están implementadas. En las pruebas multipartitas, creo que es un problema con su análisis y construcción de sintaxis, pero nunca he podido encontrar la causa raíz. Entonces espero que puedas darme algunas sugerencias, gracias.
Clave: Los segmentos de código marcados 1 y 2 están en negrita y subrayados. Si el comentario no está marcado, la prueba indica que el valor de la cadena no se puede pasar a la declaración final.
El código es el siguiente:
/////////////Archivo de encabezado ch3hdr.h
#Define NSYMS 20
Tabla de símbolos de estructura {
char * nombre
int tipo;
doble(* funcptr)();
Valor doble;
char * str
} symtab[NSYMS];
struct symtab * symlook();
/ /// ///////////Análisis léxico mylexer.l
%{
#Incluir " myparser.h "
# incluir & ltstdio .h & gt
# incluir & ltstdlib.h & gt
#Incluir "ch3hdr.h"
# incluir & ltmath.h & gt
p>%}
%%
([0-9]+|([0-9]*\.[0-9] +)([eE ][-+]? [0-9]+)?) {
yylval . dval = atof(YY text); //itoa
Cantidad devuelta. ;}
[\ t];
"+" { return ADD;}
"-"{ return DEC;}
"*"{ return MUL;}
"/"{ return DIV;}
"(" { return LPAR}
")"{return RPAR;}
" = " {return QUE;}
","{return comma;}
"$"{ return 0;}
//[\"]([A-Za-z0-9 ]*)[\"] {
[\"]([^\"]*)[\" ] {
yylval.sval = yytext
Cadena de retorno;}
[A-Za-z][A-Za-z0-9]* {
struct symtab * sp = symlook(YY text);
yylval.symp = sp
Nombre de retorno;}
[ . \n]Devuelve texto YY[0];
%%
///////////////////Analizar mi analizador .
%{
#Incluir "mylexer.h"
#Incluir "ch3hdr.h"
# incluir & ltstring.h & gt
# incluir & ltmath.h & gt
# incluir & ltstdio.h & gt
# incluir & ltstdlib.h & gt
# define MAXBUFF 100
%}
% unión {
doble dval
char * sval
struct symtab * symp
}
% token & ltsymp & gtname
% token & ltdval & gtnumber
% token & ltsval & gt line
%token QUE agregar DEC MUL DIV LPAR RPAR coma
%left más decimal
%left división multiplicada
% aluminio sin sacarosa
% ty
pe & ltdval & gt significa
% tipo & ltsval & gtstringexp
%%
Statement_list: declaración ' \n '
| Declaración_lista de declaraciones '\n'
Declaración: expresión QUE denominada { $1->; $1->; ; nombre, $3); }
| nombre QUE cadenaexp { $1->; valor = 0; cadena %; s es %s\n ", $1->nombre, $1->str);}
| expresión { printf(" expresión = % g \ n ", $ 1); }
| cadena exp { printf(" cadena exp = % s \ n ", $ 1 }
cadena XP:expresión AGREGAR cadena p>
//| { $ $ =(char *)malloc(sizeof(char *)max buff); sprintf($$, " %s%s\n ", $1, $ 3 } - 1
/); /| cadena exp AGREGAR expresión { $ $ =(char *)malloc(sizeof(char *)max buff } - 2
| strrev (strn set(strrev(strn set($ 1); ), ' ', 1)), '', 1); sprintf ($$, " %s ", $ 1 }
expresión: expresión AGREGAR expresión { $ $ = $ 1+$); 3;}
| NÚMERO { $ $ = $ 1;}
| expresión expresión DEC { $ $ = $ 1-$ 3;}
| expresión expresión MUL { $ $ = $ 1 * $ 3;}
|expresión expresión DIV {
if ($3= 0.0)
yyerror("divide por cero");
Otro
$$ = $1 / $3;
}
}
p>| expresión DEC % prec UMINUS { $ $ =-$ 2;}
| expresión LPAR RPAR { $ $ = $ 2;}
| ->valor}
|nombre lpar expresión rpar {
if($1->funcptr)
$ $=($1->funcptr)($3) ;
En caso contrario{
printf("%s no es una función\n", $1->nombre) ;
$$=0.0;
}
}
|Nombre expresión LPAR expresión coma RPAR {
if($1->funcptr)
$ $ =($1->funcptr)($3,$5);
De lo contrario {
printf("%s no es una función\n ", $ 1-& gt; nombre
$$=0.0;
p>}
}
%%
Tabla de símbolos de estructura * tabla de símbolos (carácter)
{
struct symtab * sp
for(sp = symtab;sp & lt& ampsymtab[NSYMS];sp++)
{
if(sp- >Nombre& strcmp(sp->Nombre)
return sp;
if (!sp->Nombre)
{
sp-& gt;nombre = strdup(s);
Devolver sp;
}
}
yyerror("Demasiados símbolos");
Salir (1);
}
addfunc(char *nombre, doble ( *func)( ))
{
struct symtab * sp = symlook(nombre);
sp-& gt;
Principal (nulo)
{
doble externo sqrt(), exp(), log(), atan2(), fmod();
addfunc("sqrt",sqrt);
addfunc("exp",exp);
addfunc("log",log
);addfunc("atan2 ", atan 2);
addfunc("fmod ", fmod);
YY parse(); /p>
Reimprimir