[PDF] [PDF] Générer un analyseur avec Flex&Bison - ENIB

[PDF] Générer un analyseur avec Flex&Bison - ENIB

Yacc/Bison : Yet Another Compiler Compiler Reconnaisseur de langages non contextuels Grammaire non contextuelle → code C d'un analyseur syntaxique

[PDF] Réalisation dun compilateur en utilisant LEX et YACC

simplifiée du langage C en utilisant le générateur d'analyseur lexical LEX et le générateur d'analyseur syntaxique YACC (Yet Another Compiler Compiler )

[PDF] lex et yacc

ici flex yacc : générateur d'analyseur syntaxique Prend en entrée la définition d' un schéma de traduction Partie 1 : déclarations pour le compilateur C }

[PDF] Compiler Construction using Flex and Bison - ADMB Project

The file file tab c defines the C function yyparse() which is the parser Yacc is distributed with the Unix operating system while Bison is a product

[PDF] Introduction à la compilation - Département dinformatique de l

Flex et Bison ➢ Années 70 : Lex Yacc Lex : Lexical analyser (analyseur lexical) Yacc : Yet Another Compiler Compiler (analyseur syntaxique) Lex et Yacc 

[PDF] Réaliser un Compilateur Licence Informatique

28 jan 2009 · Lex et Yacc ▻ Analyse lexicale = découpage en mots `a l'aide de grammaires réguli`eres ▻ Analyse syntaxique = découpage en phrases `a 

[PDF] Interprétation et Compilation (HLIN604) - LIRMM

14 jan 2016 · 3 3 Un langage et un outil pour l'analyse syntaxique : yacc l'étude des compilateurs et des langages de programmation Aprés compilation : bison - ydtv parserminiC++ y puis g++ -o mini y tab c, on obtient l'exécutable 

[PDF] REALISATION DUN INTERPRETEUR ET DE SON EDITEUR POUR

Ce formulateur est un interpréteur d'un mini langage de programmation interne Il n'existe pas de compilateur pour créer Lex Yacc, mais bizarrement leur

[PDF] Compiler Construction using Flex and Bison - AGH

Parsing is complete when the entire program has been reduced to the start symbol of the grammar Compiling the Yacc file with the command yacc -vd file y ( bison 

[PDF] flex & bison

This demonstrates one of flex's strengths—it's easy to make small changes to that uses bison to generate a C parser that's compiled by the C++ compiler, with 

[PDF] analyseur lexical avec flex

[PDF] flex et bison pdf

[PDF] analyseur syntaxique avec flex et bison

[PDF] exercice flex avec correction

[PDF] lex yacc exemple

[PDF] allocution bienvenue association

[PDF] fin de la démocratie athénienne

[PDF] l'apogée d'athènes

[PDF] fondation d'athènes

[PDF] apogée d'athènes date

[PDF] auteurs francophones connus

[PDF] liste des auteurs africains et leurs oeuvres pdf

[PDF] auteurs francophones contemporains

[PDF] littérature francophone est elle une littérature française

[PDF] auteurs francophones africains

%Techniques de compilation enib, F.H ... 1/44Generer un analyseur avecFlex&Bison

Generalites

Analyse lexicale avecFlex

Analyse syntaxique avecBison

Association deFlexetBisonFabriceHarrouet

Ecole Nationale d'Ingenieurs de Brest

harrouet@enib.fr http://www.enib.fr/~harrouet/ %Flex&Bisonenib, F.H ... 2/44Origine des outils.Lex&Yacc

Generateurs d'analyseurs lexicaux/syntaxiques enC

'annees 1970, laboratoiresBell

OutilsUNIX(Posix) standards

+ de nombreuses variantes (commerciales ou non) .Flex&Bison

VersionGNUdeLex&Yacc

Flex:\fastLex"Bison: jeu de mot surYacc

Beaucoup de possibilites supplementaires !

Disponible pour un tres grand nombre de plateformes .9de nombreux outils dierents ayant le m^eme propos

AntLR,Spirit...

On retrouve des choses issues deLex&Yacc

%Flex&Bisonenib, F.H ... 3/44Principe des outils .Lex/Flex:LEXical analyzer

Reconnaisseur de langages reguliers

Expressions rationnelles!codeCd'un analyseur lexical

Permet de reconna^tre lesmotsd'un langage

.Yacc/Bison:Yet Another Compiler Compiler

Reconnaisseur de langages non contextuels

Grammaire non contextuelle!codeCd'un analyseur syntaxique

Permet de reconna^tre lesphrasesd'un langage

%Flex&Bisonenib, F.H ... 4/44Principe des outilsBisonCompilation et

édition de liens

Fichier Flex

Fichier BisonFichier C

Fichier C

Fichiers CExécutable

Flex.Generation d'analyseurs statiques et non dynamiques Le codeCproduit est specique au langage a reconnaitre!ecacite Compilation du code genere comme le reste de l'application Modif du langage!regeneration du code des analyseurs %A. lexicale enFlexenib, F.H ... 5/44Structure d'un programmeFlex%{ %}Pré-code C

Définitions et options

Règles de production

Post-code CFichier FlexFichier C généré

Déclarations, macros

Tables d"analyse

Copie du pré-code C

Copie du post-code Cint yylex(void)

Copie du code C

Autres fonctions ....Pre/post-codeC:duCtout a fait classique .Options :%quelquechosepour parametrer le fonctionnement .Denitions :Expressions rationnelles auxquelles on attribue un nom .Regles de production :AssociationsER!codeCa executer %A. lexicale enFlexenib, F.H ... 6/44Expressions rationnelles enFlex.Comprend lesER POSIX

Voir le cours correspondant

.Quelques possibilites supplementaires

Unatomepeut ^etre une cha^neClitterale

ex :"ab"f3g !ababab

Les caracteres speciaux duCsont reconnus

ex :Hello\tWorld,Hello\123World,Hello\x2aWorld La notationf gpermet aussi de reutiliser uneERnommee ex :(fintegerg|frealg)?(integeretrealdenies avant)

L'atome<>represente la n de chier

Lesstart-conditions(voir plus loin)

%A. lexicale enFlexenib, F.H ... 7/44SyntaxeFlex.Denition desERnommees Un nomcolle a gauche, une ou plusieurs espaces, uneER ex :integer [1-9][0-9]*|0 ex :indent [a-zA-Z][0-9a-zA-Z]* .Regles de production UneERcollee a gauche, une ou plusieurs espaces, du codeC Code sur une seule ligne ou bloc avecfsur la m^eme ligne que l'ER ex :fintegergcerr << "INTEGER" << endl; ex :findentg f cerr << "IDENT" << endl; g Les commentairesne doivent pas^etre colles a gauche (!ER!) %A. lexicale enFlexenib, F.H ... 8/44L'analyseur genere.La fonctionint yylex(void)

Extrait des caracteres du

uxyyin(stdinpar defaut) Confronte les sequences auxERdes regles de production Test de haut en bas,la plus longuecorrespondance est retenue

Execute les actions semantiques (codeC) associees

Variableyytext: cha^ne de caracteres correspondant a l'ER

Variableyyleng: longueur deyytext

Ecrit lesnon-correspondancessuryyout(stdoutpar defaut) Jusqu'a la n de chier ou unreturndans les actionsC .La valeur de retour

0en cas de n de chier

Un code numerique (#define,enum) indiquant l'ERreconnue !Analyse lexicale %A. lexicale enFlexenib, F.H ... 9/44Compteur de lignes, mots et caracteres%{ int nbChar=0,nbWord=0,nbLine=0; $ %} $ flex -oprog.c prog.l $ gcc -oprog prog.c /* doesn't need yywrap() */ $ ./prog < prog.l %option noyywrap 24 39 347 endOfLine \n character [^ \t\n] {endOfLine} { ++nbChar; ++nbLine; } {character}+ { nbChar+=yyleng; ++nbWord; } . { ++nbChar; } int main(void) yylex(); return(0); %A. lexicale enFlexenib, F.H ... 10/44Un analyseur trivial%{ $ cat file.txt %} var1=123*45.67; %option noyywrap _attr+=var1; integer [0-9]+ $ ./prog < file.txt real [0-9]+\.[0-9]*|\.[0-9]+ IDENT [var1] ident [a-zA-Z_][0-9a-zA-Z_]* UNKNOWN [=] %% INTEGER [123] {real} { fprintf(stderr,"REAL [%s]\n",yytext); } UNKNOWN [*] {integer} { fprintf(stderr,"INTEGER [%s]\n",yytext); } REAL [45.67] {ident} { fprintf(stderr,"IDENT [%s]\n",yytext); } UNKNOWN [;] \n { fprintf(stderr,"NEW_LINE [%s]\n",yytext); } NEW_LINE [ . { fprintf(stderr,"UNKNOWN [%s]\n",yytext); } ] %% IDENT [_attr]

UNKNOWN [+]

int UNKNOWN [=] main(void) IDENT [var1] { UNKNOWN [;] yylex(); NEW_LINE [ return(0); ] %A. lexicale enFlexenib, F.H ... 11/44Un analyseur plus conventionnel | 1/2%{ $ cat file.txt #include var1=123*45.67; enum {INTEGER=1,REAL,IDENT,NEW_LINE,UNKNOWN}; _attr+=var1; char globalValue[0x100]; $ ./prog < file.txt %} IDENT [var1]

UNKNOWN [=]

%option noyywrap INTEGER [123]

UNKNOWN [*]

integer [0-9]+ REAL [45.67] real [0-9]+\.[0-9]*|\.[0-9]+ UNKNOWN [;] ident [a-zA-Z_][0-9a-zA-Z_]* NEW_LINE [ %% IDENT [_attr]

UNKNOWN [+]

{real} { strcpy(globalValue,yytext); return(REAL); } UNKNOWN [=] {integer} { strcpy(globalValue,yytext); return(INTEGER); } IDENT [var1] {ident} { strcpy(globalValue,yytext); return(IDENT); } UNKNOWN [;] \n { strcpy(globalValue,yytext); return(NEW_LINE); } NEW_LINE [ . { strcpy(globalValue,yytext); return(UNKNOWN); } ]

END_OF_FILE

%A. lexicale enFlexenib, F.H ... 12/44Un analyseur plus conventionnel | 2/2int main(void) int token; do token=yylex(); switch(token) case 0: fprintf(stderr,"END_OF_FILE\n"); break; case INTEGER: fprintf(stderr,"INTEGER [%s]\n",globalValue); break; case REAL: fprintf(stderr,"REAL [%s]\n",globalValue); break; case IDENT: fprintf(stderr,"IDENT [%s]\n",globalValue); break; case NEW_LINE: fprintf(stderr,"NEW_LINE [%s]\n",globalValue); break; case UNKNOWN: fprintf(stderr,"UNKNOWN [%s]\n",globalValue); break; } while(token); return(0); %A. lexicale enFlexenib, F.H ... 13/44Une calculette a pile | 1/2%{ $ cat calc.txt #include 1 2 + #include 4 * using namespace std; 5 10 - @/ enum {VALUE=1,PLUS,MINUS,MULT,DIV}; $ ./prog calc.txt double val; --> 1 %} --> 1 2 --> 3 %option noyywrap --> 3 4 --> 12 integer [0-9]+ --> 12 5 real [0-9]+\.[0-9]*|\.[0-9]+ --> 12 5 10 value {integer}|{real} --> 12 -5 lexical error: @ %% --> -2.4 {value} { sscanf(yytext,"%lf",&val); return(VALUE); } --> -2.4 "+" { return(PLUS); } $ "-" { return(MINUS); } "*" { return(MULT); } "/" { return(DIV); } [ \t\n]+ { /* nothing to be done */ } . { cerr << "lexical error: " << yytext << endl; } %A. lexicale enFlexenib, F.H ... 14/44Une calculette a pile | 2/2int main(int argc,char ** argv) vector s; int token; if(argc>1) yyin=fopen(argv[1],"r"); // check result !!! do double x1,x2; token=yylex(); switch(token) case VALUE: s.push_back(val); break; case PLUS: x2=s.back(); s.pop_back(); x1=s.back(); s.pop_back(); s.push_back(x1+x2); break; case MINUS: /* ... x1-x2 ... */ break; case MULT: /* ... x1*x2 ... */ break; case DIV: /* ... x1/x2 ... */ break; cerr << "-->"; for(size_t i=0;iERdans les regles de production Les regles qui commencent parou sans<>sont valables quand on est dans la conditionname .Conditions exclusives %x namedans les options,ERdans les regles de production Seules les regles qui commencent parsont valables quand on est dans la conditionname .Changement de condition BEGIN(name)dans le codeCplace l'analyseur dans la conditionname BEGIN(INITIAL)pour revenir dans l'etat de depart (regles sans<>) %A. lexicale enFlexenib, F.H ... 16/44Reconna^tre des cha^nesC| 1/3%{ $ #include $ cat string.txt #include 123 using namespace std; "ab\tcd\n456\"hello" enum {STRING=1,INTEGER}; 789 "toto string val; $ ./prog string.txt int nbLines; INTEGER[123] %} STRING[ab cd

456"hello]

%option noyywrap INTEGER[789] multi-line strings not allowed %x strEnv STRING[toto]

3 lines

integer [0-9]+ $

%A. lexicale enFlexenib, F.H ... 17/44Reconna^tre des cha^nesC| 2/3{integer} { val=yytext; return(INTEGER); }

"\"" { val.clear(); BEGIN(strEnv); } "\"" { BEGIN(INITIAL); return(STRING); } "\\a" { val+='\a'; } "\\b" { val+='\b'; } "\\f" { val+='\f'; } "\\n" { val+='\n'; } "\\r" { val+='\r'; } "\\t" { val+='\t'; } "\\v" { val+='\v'; } "\\\\" { val+='\\'; } "\\\"" { val+='\"'; } "\n" { cerr << "multi-line strings not allowed" << endl; ++nbLines; } "\\\n" { val+='\n'; ++nbLines; } // line cut by \ "\\". { val+=yytext[1]; } <> { BEGIN(INITIAL); return(STRING); } . { val+=yytext[0]; } [ \t]+ { /* nothing to be done */ } "\n" { ++nbLines; } . { cerr << "lexical error: " << yytext << endl; } %A. lexicale enFlexenib, F.H ... 18/44Reconna^tre des cha^nesC| 3/3%% int main(int argc,char ** argv) int token; if(argc>1) yyin=fopen(argv[1],"r"); // check result !!! do token=yylex(); switch(token) case STRING: cerr << "STRING[" << val << "]" << endl; break; case INTEGER: cerr << "INTEGER[" << val << "]" << endl; break; } while(token); cerr << nbLines << " lines" << endl; return(0);

%A. lexicale enFlexenib, F.H ... 19/44Quelques remarques.Utilisation de variables globales (internes et applicatives)

Chaque invocation analyse la suite du

ux, l'etat est sauve Plusieurs analyseurs dierents!PB a l'edition de liens Non reentrant!PB si plusieurs analyses simultanees .L'ordre des regles est important Commencer par le plus specique, nir par le plus general ex :fidentgdoit ^etre pris en compteapresles mot-clefs La plus longue correspondance est tout de m^eme preferee ex :formest reconnu comme unfidentgm^eme si le mot-clef forest teste avant. .Beaucoup d'autres options, fonctions, macros, variables

Le minimum est vu ici, tres proche duLexoriginel

Permettent des horreurs, ou de contourner certaines limitations %A. syntaxique enBisonenib, F.H ... 20/44Structure d'un programmeBison%{ %}Pré-code C

Définitions et options

Règles de production

Post-code CFichier BisonFichier C généré

Déclarations, macros

Copie du post-code Cint yyparse(void)

Copie du code C

Autres fonctions ...Tables d"analyse

Copie du pré-code C.Pre/post-codeC:duCtout a fait classique .Options :%quelquechosepour parametrer le fonctionnement .Denitions :%autrechosepour denir les lexemes, les priorites ... .Regles de production :Regles de grammaires et codeCa executer %A. syntaxique enBisonenib, F.H ... 21/44SyntaxeBison.Regles de production nonterminal : sequencedesymbolesf/* code C */g| autresequencef/* code C */g| ...; Les symboles sont representes par des identicateurs Terminaux : lexemes provenant de l'analyse lexicale Non-terminaux : symboles internes a l'analyseur syntaxique Le codeCest optionnel et est execute lorsque la regle est reduite program : START instList END { cerr << "program" << endl; } ;instList : instList inst| inst

;inst : IDENT ASSIGN expr SEMICOLON { cerr << "inst" << endl; };expr : INTEGER { cerr << "integer expr" << endl; }

| REAL { cerr << "real expr" << endl; }| IDENT { cerr << "ident expr" << endl; }; %A. syntaxique enBisonenib, F.H ... 22/44L'analyseur genere.La fonctionint yyparse(void) Consomme les lexemes obtenus par des appels ayylex()(a fournir) int yylex(void); Verie (LALR(1)) si la sequence de lexemes permet de reduire l'axiome de la grammaire exprimee (%start nonterminaldans les denitions) Execute les actions semantiques (codeC) associees aux regles reduites Signale les erreurs a l'aide de la fonctionyyerror()(a fournir) void yyerror(const char * msg); Possibilite de recuperation sur erreur pour poursuivre l'analyse Jusqu'a ce que l'axiome de la grammaire soit reconnu ou erreur .La valeur de retour

0si ok,1si erreur

Resultat de l'analyse complete!une seule invocation %A. syntaxique enBisonenib, F.H ... 23/44AssociationFlex/Bison.Flexfourni les lexemes aBison

Bisoninvoque la fonctionyylex()produite parFlex

yylex()doit renvoyer des constantes connues deBison !%token IDENT INTEGER ...dans les denitions deBison Bisongenere un.hdenissant ces constantes (et d'autres choses)

Le pre-codeCdeFlexinclu ce.h

Etapes de la construction :

$ bison -d -oprogY.cpp prog.y !Produit le codeCprogY.cppdepuis le chierBisonprog.y !Option-dpour generer le.h progY.hpp $ flex -oprogL.cpp prog.l !Produit le codeCprogL.cppdepuis le chierFlexprog.l !Le pre-codeCdoit inclureprogY.hpp $ g++ -oprog progL.cpp progY.cpp

%A. syntaxique enBisonenib, F.H ... 24/44Analyse syntaxique simple | 1/4%{ /*-------- prog.l --------*/

extern int lineNumber; // definie dans prog.y, utilise par notre code pour \n void yyerror(const char * msg); // definie dans prog.y, utilise par notre code pour . #include "progY.hpp" // genere par prog.y --> constantes START, END ... %option noyywrap integer [0-9]+ real [0-9]+\.[0-9]*|\.[0-9]+ ident [a-zA-Z_][0-9a-zA-Z_]* "start" { return(START); } "end" { return(END); } ":=" { return(ASSIGN); } ";" { return(SEMICOLON); } {ident} { return(IDENT); } {real} { return(REAL); } {integer} { return(INTEGER); } "\n" { ++lineNumber; } [ \t]+ { /* nothing to be done */ } . { char msg[0x20]; sprintf(msg,"lexical error <%s>",yytext); yyerror(msg); }

%A. syntaxique enBisonenib, F.H ... 25/44Analyse syntaxique simple | 2/4%{ /*-------- prog.y --------*/

#include #include using namespace std; int yylex(void); // defini dans progL.cpp, utilise par yyparse() void yyerror(const char * msg); // defini plus loin, utilise par yyparse() int lineNumber; // notre compteur de lignes extern FILE * yyin; // defini dans progL.cpp, utilise par main() %token START END // les lexemes que doit fournir yylex() %token ASSIGN SEMICOLON %token IDENT REAL INTEGER %start program // l'axiome de notre grammaire

%A. syntaxique enBisonenib, F.H ... 26/44Analyse syntaxique simple | 3/4program : START instList END { cerr << "program" << endl; }

instList : instList inst | inst inst : IDENT ASSIGN expr SEMICOLON { cerr << "inst" << endl; } expr : INTEGER { cerr << "integer expr" << endl; } | REAL { cerr << "real expr" << endl; } | IDENT { cerr << "ident expr" << endl; } void yyerror(const char * msg) cerr << "line " << lineNumber << ": " << msg << endl; int main(int argc,char ** argv) if(argc>1) yyin=fopen(argv[1],"r"); // check result !!! lineNumber=1; if(!yyparse()) cerr << "Success" << endl; return(0);

%A. syntaxique enBisonenib, F.H ... 27/44Analyse syntaxique simple | 4/4$ bison -d -oprogY.cpp prog.y

$ flex -oprogL.cpp prog.l $ g++ -oprog progL.cpp progY.cpp $ cat file1.txt $ cat file2.txt $ cat file3.txt start start start a := 1 ; a := -1 ; a := 1 ; b := 2.3 ; b := 2,3 ; b := 2.3 ; c := a ; c := a ; c := a ; end end end $ ./prog file1.txt $ ./prog file2.txt and then ... integer expr line 2: lexical error <-> $ ./prog file3.txt inst integer expr integer expr real expr inst inst inst integer expr real expr ident expr line 3: lexical error <,> inst inst line 3: parse error ident expr program $ inst

Success program

$ line 6: parse error

%A. syntaxique enBisonenib, F.H ... 28/44Valeurs associees aux symboles.Chaque symbole peut contenir une valeur

Au-dela de l'analyse syntaxique!analyse semantique %unionf...gdans les denitions deBison(unionC) .Valeur d'un symbole!un seul champ de l'union %type symbolesdans les denitions deBison .Acces aux valeurs depuisBison

Dans le code associe anonterminal : symboles

$$valeur associee au non-terminal de la partie gauche (ecriture) $1valeur associee au premier symbole de la partie droite (lecture) $2,$3...pour les autres symboles de la partie droite

Si pas de codeC!equivalent def$$=$1;gpar defaut

Attention aux%type!warnings

Inhiber avec du code videfg

%A. syntaxique enBisonenib, F.H ... 29/44Initialiser la valeur associee a un lexeme .Variable globaleyylvalde type%union

Declaree dans le.hgenere parBison

yylex()doit initialiser cette variable yyparse()recupere cette valeur juste apres l'appel ayylex() .Choix du champ de l'union yylex()ne connait pas les%type Initialiser dansyylvalle champ indique par le%typedu lexeme Aucune verication de la coherence par les outils !

Responsabilite du programmeur

%A. syntaxique enBisonenib, F.H ... 30/44Analyse syntaxique avec passage de valeurs | 1/2%{ /*-------- prog.l --------*/ $ bison -d -oprogY.cpp prog.y

/* idem ``Analyse syntaxique simple'' */ $ flex -oprogL.cpp prog.l %} $ g++ -oprog progL.cpp progY.cpp %option noyywrap $ cat file.txt integer [0-9]+ start real [0-9]+\.[0-9]*|\.[0-9]+ a := 1 ; ident [a-zA-Z_][0-9a-zA-Z_]* b := 2.3 ; %% c := a ; "start" { return(START); } end "end" { return(END); } $ ./prog file.txt ":=" { return(ASSIGN); } integer 1 ";" { return(SEMICOLON); } assign a with i:1 {ident} { sprintf(yylval.str,"%s",yytext); real 2.3 return(IDENT); } // %type IDENT assign b with r:2.3 {real} { sscanf(yytext,"%lf",&yylval.real); ident a return(REAL); } // %type REAL assign c with s:a {integer} { sscanf(yytext,"%d",&yylval.integer); program return(INTEGER); } // %type INTEGER Success "\n" { ++lineNumber; } $ [ \t]+ { /* nothing to be done */ } . { char msg[0x20]; sprintf(msg,"lexical error <%s>",yytext); yyerror(msg); }

%A. syntaxique enBisonenib, F.H ... 31/44Analyse syntaxique avec passage de valeurs | 2/2%{ /*-------- prog.y --------*/

/* idem ``Analyse syntaxique simple'' */ %token START END ASSIGN SEMICOLON IDENT REAL INTEGER %union { char str[0x100]; double real; int integer; } %type IDENT expr %type REAL %type INTEGER %start program program : START instList END { cerr << "program" << endl; } instList : instList inst | inst inst : IDENT ASSIGN expr SEMICOLON { cerr << "assign " << $1 << " with " << $3 << endl; } expr : INTEGER { cerr << "integer " << $1 << endl; sprintf($$,"i:%d",$1); } | REAL { cerr << "real " << $1 << endl; sprintf($$,"r:%g",$1); } | IDENT { cerr << "ident " << $1 << endl; sprintf($$,"s:%s",$1); } /* idem ``Analyse syntaxique simple'' */

%A. syntaxique enBisonenib, F.H ... 32/44Une calculette a pile ... sans pile ! | 1/2%{ /*-------- prog.l --------*/ $ bison -d -oprogY.cpp prog.y

/* idem ``Analyse syntaxique simple'' */ $ flex -oprogL.cpp prog.l %} $ g++ -oprog progL.cpp progY.cpp %option noyywrap $ echo "1 2 + 4 * 5 10 - /" | ./prog integer [0-9]+ value=1 real [0-9]+\.[0-9]*|\.[0-9]+ value=2 value {integer}|{real} 1+2=3 %% value=4 {value} { 3*4=12 sscanf(yytext,"%lf",&yylval.val); value=5 return(VALUE); value=10 } 5-10=-5 "+" { return(PLUS); } 12/-5=-2.4 "-" { return(MINUS); } Result: -2.4 "*" { return(MULT); } Success "/" { return(DIV); } $ "\n" { ++lineNumber; } [ \t]+ { /* nothing to be done */ } . { char msg[0x20]; sprintf(msg,"lexical error <%s>",yytext); yyerror(msg);

%A. syntaxique enBisonenib, F.H ... 33/44Une calculette a pile ... sans pile ! | 2/2%{ /*-------- prog.y --------*/

quotesdbs_dbs20.pdfusesText_26