INE 11

(1)

Principes des lang. de progr.

INE 11

Michel Mauny

Inria-Paris

pré[email protected]

Michel Mauny (Inria-Paris) INE 11 pré[email protected] 1 / 25

Analyse syntaxique

1 Grammaires

2 Analyse

Analyse descendante Analyse ascendante

3 OCamlyacc

Analyse syntaxique

Seconde phase d’un compilateur ou interprète

analyseur sémantique analyseur syntaxique analyseur lexical programme

source (flux de caractères)

Flux de lexèmes

Arbre de syntaxe dite superficielle

Arbre de syntaxe dite profonde

générateur

Code objet

(2)

Analyse syntaxique

Seconde phase d’un compilateur ou interprète analyseur peut être écrit à la main

le plus souvent produit automatiquement à partir d’un générateur spécifié à partir d’une grammaire

Domaine bien étudié théorie bien comprise littérature abondante générateurs performants L’analyseur syntaxique

refuse des programmes n’appartenant pas au langage (auxquels on ne saurait pas donner de sens)

construit une représentation structurée des programmes acceptés

Grammaires

On définit un langage à l’aide d’unegrammaire:

digit→’0’ | ’1’ | ’2’ | ’3’ | ’4’ | ’5’ | ’6’ | ’7’ | ’8’ | ’9’

nat→chiffre|chiffre nat expr→nat|expr’+’expr

Une grammaire G est un quadruplet (N,T,P,S)où : N est un ensemble fini de symboles ditsnon terminaux T est un ensemble de symboles ditsterminaux

P est l’ensemble desproductions: c’est un sous-ensemble de (N∪T)^∗N(N∪T)^∗×(N∪T)^∗

On noteα→β un élément(α, β)deP

S est un symbole particulier deN et est appelé lesymbole de départ.

Grammaires

Notation :

on regroupe les règlesα→βi ayant le même membre gaucheα, en α→β1|β2|. . .|βn

Notation BNF (Backus-Naur Form) :c’est le nom qu’on donne à ces notations de grammaire. Utilisée pour la définition du langage Algol (≈

1960)

Notation EBNF (Extended BNF) : BNF

+ crochets[. . .]pour des éléments optionnels + accolades{. . .}pour l’étoile et{. . .}⁺

(3)

Hiérarchie de Chomsky

Hiérarchie de Chomsky . Une grammaire est dite :

de type 3 ou rationnellesi chaque production est ou bien de la forme A→wB ouA→w oùAetB sont des non terminaux etw est un terminal, ou alors de la formeA→;

de type 2 ou algébriqueounon contextuellesi chaque production est de la forme A→αoùAest un non terminal etαest une séquence de terminaux ou non terminaux ;

de type 1 ou contextuellesi chaque production est de la forme αAβ →αγβ oùα,β etγ sont des séquences de terminaux ou non terminaux etγ6=;

de type 0 ou généralesi chaque production est de la formeα→β, sans autre contrainte.

Exemples

Rationnelle :

a^∗bc^∗

S→aS S →bC C→ C→cC

Algébrique (non contextuelle) :

aⁱbⁱ

avec

i >

0

S →aSb S →ab

Contextuelle :

aⁱbⁱcⁱ

avec

i >

0

S→aSBC S→aBC Ca→aC Ba→aB CB→BC aB→ab bB→bb bC →bc cC →cc

(En fait,CB →BC n’est pas de type 1, maisCB →HB→HC→BC l’est, et est équivalente.)

Grammaires algébriques

Productions de la forme A→α

LangageL(G)engendré parG :l’ensemble des suites finiesw de terminaux que l’on peut dériver deS par la méthode suivante, oùαest ce qui a été dérivé jusqu’alors (initialement,α=S) :

1 siαest une suitew composée uniquement de terminaux, alors w ∈ L(G);

2 sinonα=βAγoùAest un non terminal : considérons une production A→δet remplaçonsαparβδγ, et recommencer en 1.

(4)

Exemple

Grammaire des expressions arithmétiques

S → E E → E + E E → E − E E → E ∗ E E → E / E E → ( E ) E → INT

Terminaux : constantes entières littérales, opérateurs et parenthèses.

Non-terminaux :E etS, et symbole de départ :S.

Dérivations

Plusieurs dérivations possibles pour1+2∗3 S ⇒ E

⇒ E +E

⇒INT1+ E

⇒INT1+ E ∗E

⇒INT1+INT2∗ E

⇒INT1+INT2∗INT3

S ⇒ E

⇒ E ∗E

⇒ E +E∗E

⇒INT1+ E ∗E

⇒INT1+INT2∗ E

⇒INT1+INT2∗INT3

S ⇒ E

⇒E+ E

⇒E+E∗ E

⇒E+ E ∗INT3

⇒ E +INT2∗INT3

⇒INT1+INT2∗INT3

Arbres d’analyse et de syntaxe

(5)

Analyse descendante

Interpréter les non-terminaux comme des fonctions :

parse_E: flux d’entrée→oui/non (ouSome(arbre)/None) E → E + E

E → E − E . . .

E → ( E ) E → INT Problèmes :

récursion gauche :

parse_E() =parse_E()puisreconnaître ’+’puisparse_E() factorisation

⇒transformer la grammaire

Transformation de grammaires

Éliminer la récursion gauche :

S → P+S P → F∗P

S → P−S P → F/P F → (S)

S → P P → F F → INT

Factoriser :

S → P Opa S

S → P

(idem pourP avecOpm) Opa → +

Opa → −

Factoriser :

S → P R R → Opa S R →

. . .

Analyse ascendante

Principe

empiler les lexèmes (shift)

réduire (reduce) une production (remplacer le segment terminalαde la pile parAsiA→α)

Implémentation

ne s’écrit jamais à la main

générateurs efficaces (Yacc, Bison, . . . ) d’analyseurs à partir de grammaires :

1 analyse de la grammaire, messages d’avertissement éventuels

2 génération d’un automateà pile(pushdown automaton) LR (Left-to-right scan,Rightmost derivation)

(6)

Généralités

Avantages

lisibilité, «maintenabilité»

efficacité

Inconvénients

mise au point quelquefois difficile

OCamlyacc

Générateur d’analyseurs ascendants pour OCaml similaire à Yacc (pour C, mais aussi Java, etc) grammaires LALR(1) : LR(1) + compaction de tables grammaire + actions dans un fichierparser.mly résultat dansparser.mlietparser.ml

OCamlyacc

Structure deparser.mly

%{

prélude (∗ commentaires OCaml∗)

%}

déclarations /* commentaires à la C */

%%

règles /* commentaires à la C */

%%

postlude (∗ commentaires OCaml∗)

(7)

Structure de parser.mly

Prélude :code OCaml, recopié dans le résultat Déclarations :

%token<int>INT /* déclaration des lexèmes */

%tokenPLUS MINUS TIMES DIV

%tokenLPAREN RPAREN

%tokenEOL

%leftPLUS MINUS /* précédente faible */

%leftTIMES DIV /* précédente moyenne */

%nonassocUMINUS /* précédente forte */

%startmain /* le point d’entrée */

%type<int>main /* et son type */

Structure de parser.mly

Règles :productions de grammaire + actions

productions : séquences de terminaux et non-terminaux actions : expressions OCaml entre { accolades }

main:expr EOL { $1 }

; expr:

INT { $1 }

| LPAREN expr RPAREN { $2 }

| expr PLUS expr { $1 +$3 }

| expr MINUS expr { $1−$3 }

| expr TIMES expr { $1∗$3 }

| expr DIV expr { $1 /$3 }

| MINUS expr%precUMINUS{−$2 }

;

Dans les actions, les résultats de non-terminaux et les valeurs des lexèmes sont représentés par des$1,$2, . . .

OCamlyacc : interface de l’analyseur

$ ocamlyacc parser.mly produit le fichiersparser.mli:

typetoken=

INTof(int) | PLUS | MINUS| TIMES

| DIV| LPAREN |RPAREN|EOL val main:

(Lexing.lexbuf→token)→Lexing.lexbuf→int et son implémentationparser.ml.

(8)

OCamlyacc : programme principal

Usage : let _=

try

let lexbuf =Lexing.from_channel stdinin while true do

let result =Parser.main Lexer.token lexbufin Printf.printf "%d\n%!" result

done

withLexer.Eof→exit0

Arbres de syntaxe abstraite

Type structuré OCaml (généralement récursif) typeaexpr=

| Intconstofint

| Additionofaexpr∗aexpr

| Subtractionofaexpr∗aexpr

| Multiplicationofaexpr∗ aexpr

| Divisionofaexpr∗aexpr

| Uminusofaexpr

Production d’arbres de syntaxe

expr:

INT { Intconst($1) }

| LPAREN expr RPAREN { $2 }

| expr PLUS expr { Addition($1,$3) }

| expr MINUS expr { Subtraction($1, $3) }

| expr TIMES expr { Multiplication($1,$3) }

| expr DIV expr { Division($1,$3) }

| MINUS expr%precUMINUS {Uminus($2) }

;

(9)

Conclusion

Hiérarchie des langages/grammaires

3 : rationnel (≈lexique des langages de programmation) 2 : algébrique (≈syntaxe langages de programmation) 1 : contextuel

0 : général

Syntaxe des langages

grammaires algébriques

analyse descendante, programmation directe analyse ascendante : Yacc