This document contains code for lexical and syntactic analyzers for a simple calculator language using Flex and Bison. The Flex files define patterns for tokens like numbers, operators, parentheses. The Bison grammars define the calculator language syntax with rules for expressions, terms, factors and numbers. Main functions are included to run the generated parsers. Comments provide additional context about using Flex to generate a lexer, Bison to generate a parser, and compiling the resulting files into a calculator program. Later sections show similar grammars for expressions, regular expressions and an if-else statement language.

1. Grammaire ETF fichier lex
%{
%}
let [a-zA-Z]
ch [0-9]
%%
[ tn]+ ;
{let}({let}|{ch}|_)* return (IDENT);
{ch}+ {yylval=atoi(yytext);return (N_I);}
"+" return (ADD);
"*" return (MUL);
"-" return (MOINS);
( return (P_O);
) return (P_F);
"#" return (DIEZE);
%%
//_______________________________________________________________________
Grammaire ETF fichier bison
%{
#include <stdio.h>
%}
%token ADD
%token MOINS
%token MUL
%token SUB
%token IDENT
%token N_I
%token P_O
%token P_F
%token DIEZE
%start L
%%
L : L Ep {printf("r01n");}| ;
Ep: E DIEZE {$$=$1; printf("r0");printf("=%d ",$$);}
;
E: E ADD T {$$=$1+$3; printf("r1,");}
| E MOINS T {$$=$1-$3; printf("r11,");}
| T {$$=$1; printf("r2,");}
;
T: T MUL F {$$=$1*$3; printf("r3,");}
| F {$$=$1; printf("r4,");}
;
F: P_O E P_F {$$=$2; printf("r5,");}
| N_I {$$=$1; printf("r6,");}
;
%%
#include "lex.yy.c"
int yywrap(void){
return 1;
}
int main (int argc, char *argv[]){
yyin = fopen(argv[1], "r");
yyparse();
fclose(yyin);
return 0;
}

2. advanced_cal.l
%{
#include <stdio.h>
%}
ch [0-9]
%%
[ t]+ ;
{ch}+ {sscanf(yytext,"%lf",&yylval);return (NB);}
"#" {return (DIEZE);}
n|. {return(yytext[0]);}
%%
//_____________________________________________________________________
advanced_calc.y
%{
#include <ctype.h>
#include <stdio.h>
#define YYSTYPE double /* type de la pile de yacc*/
%}
%token NB DIEZE
%left '+' '-'
%left '*' '/'
%right moins_unaire
%%
L : L Ep 'n' {printf("r01nn");}| {printf("r02nn") ;}
;
Ep: E DIEZE {$$=$1; printf("r0");printf("=%lfn",$$);}
;
E: E '+' E {$$=$1+$3;printf("r4n");}
|E '-' E {$$=$1-$3;printf("r5n");}
|E '*' E {$$=$1*$3;printf("r6n");}
|E '/' E {$$=$1/$3;printf("r7n");}
|'(' E ')' {$$=$2;printf("r8n");}
| '-' E %prec moins_unaire {$$= -$2;printf("r9n");}
| NB {printf("r10n");}
;
%%
#include "lex.yy.c"
int yywrap(void){return 1;}
int main (int argc, char *argv[]){
yyin = fopen(argv[1], "r");
yyparse();
fclose(yyin);
return 0;
}
/*
flex nom.l
bison nom.y -d -v
cc -o nom nom.tab.c -ly -ll*/

3. Grammaire expressions régulières
%{
#include <stdio.h>
%}
let [a-z]
%%
[ t]+ ;
{let}+ {return (ID);}
"#" {return (DIEZE);}
n|. {return(yytext[0]);}
%%
fichier.y
%{
#include <ctype.h>
#include <stdio.h>
#define YYSTYPE double /* type de la pile de yacc*/
%}
%token ID DIEZE
%left '|'
%left '.'
%left '*'
%%
L : L Ep 'n' {printf("r01nn");}
|{printf("r02n");}
;
Ep: E DIEZE {printf("r0n");}
;
E: E '|' E {printf("r1n");}
|E '.' E {printf("r2n");}
|E'*' {printf("r3n");}
|'(' E ')' {printf("r4n");}
| ID {printf("r5n");}
;
%%
#include "lex.yy.c"
int yywrap(void){return 1;}
int main (int argc, char *argv[]){
yyin = fopen(argv[1], "r");
yyparse();
fclose(yyin);
return 0;
}
/*
flex nom.l
bison nom.y -d -v
cc -o nom nom.tab.c -ly -ll*/

4. si alors sinon
%{
#include <stdio.h>
%}
%%
[ t]+ ;
"a" {return (A);}
"i" {return (IF);}
"e" {return (ELSE);}
"#" {return (DIEZE);}
n|. {return(yytext[0]);}
%%
//_____________ grammaire ambigue____________________
%{
#include <stdio.h>
%}
%token IF ELSE A DIEZE
%%
L : IS L { printf("r1n");}
| { printf("r0n");}
IS :I DIEZE 'n'{ printf("r2n");}
;
I : IF I { printf("r3n");}
|IF I ELSE I { printf("r4n");}
| A { printf("r5n");}
;
%%
si alors sinon priorité au décalge % à la réduction____________________
%{
#include <stdio.h>
%}
%token A IF DIEZE
%nonassoc REDUCE
%nonassoc ELSE
%%
L : IS L { printf("r1n");}
|{ printf("r0n");}
;
IS :I DIEZE 'n'{ printf("r2n");}
;
I : IF I ELSE I { printf("r3n");}
| IF I %prec REDUCE { printf("r4n");}
| A { printf("r5n");}
;
%%