Project Oscar
| |
Project Oscar |
Previous: Analyse lexicale
L'analyse syntaxique doit déboucher sur la création d'un arbre abstrait. Ce dernier viendra en entrée d'un évaluateur d'attribut pour la phase suivante d'analyse de sémantique statique. La description de cet arbre se trouve dans le fichier de syntaxe abstraite simproc-base.asx. Cette syntaxe abstraite ne contient aucune déclaration d'attribut, ceux-ci sont déclarés dans la syntaxe abstraite simproc-in.asx qui importe la syntaxe de base simproc-base.asx. Ces deux fichiers sont listés ci-dessous.
grammar simproc-base is
{Une syntaxe abstraite non attribuee, pour le langage simproc}
{============================================================}
root is PROGRAM ;
{Programme et blocs}
{==================}
PROGRAM = program ;
program -> BLOCK ;
BLOCK = block ;
block -> DECLS STMTS ;
{Declarations}
{============}
DECLS = decls ;
decls -> DECL* ;
DECL = int-decl array-decl proc-decl ;
int-decl -> ID {identificateur de variable} ;
array-decl -> ID {identificateur de variable}
NUMBER {dimension du tableau} ;
proc-decl -> ID {identificateur de procedure}
ID {identificateur de parametre par valeur}
ID {identificateur de parametre par reference}
BLOCK ;
{Instructions}
{============}
STMTS = stmt-list ;
stmt-list -> STMT+ ;
STMT = assign call ifthenelse ;
assign -> VAR EXPR ;
call -> ID {identificateur de procedure}
EXPR {paramètre valeur}
VAR {parametre par reference} ;
ifthenelse -> EXPR EXPR
STMTS {partie si vrai}
STMTS {partie si faux} ;
{Expressions}
{===========}
EXPR = bin-expr constant used-var ;
bin-expr -> OP EXPR EXPR ;
constant -> NUMBER ;
used-var -> VAR ;
OP = plus minus mul div ;
plus -> ;
minus -> ;
mul -> ;
div -> ;
{Variables}
{=========}
VAR = simple-var indexed-var ;
simple-var -> ID {Identificateur de variable};
indexed-var -> ID {identificateur de tableau}
EXPR {index};
{Terminaux}
{=========}
NUMBER = number ;
number -> ;
ID = id;
id -> ;
end grammar {simproc-base} ;
Le contenu de la syntaxe attribuée décrivant le premier arbre abstrait, est listé ci-dessous.
{Une syntaxe abstraite attribuee, pour le langage simproc}
{========================================================}
grammar simproc-in is
import grammar simproc-base ;
root is PROGRAM ;
{Attributs}
{=========}
$text (NUMBER) : token ;
$id (ID) : token ;
end grammar ;
L'arbre abstrait et la syntaxe absraite, sont très dépendants de la syntaxe concrète du langage. L'expérience prouve qu'il est très commode de décrire le fichier de syntaxe abstraite, en parallèle avec le fichier de syntaxe concrète (simproc.atc).
Nous donnons ci-dessous, la syntaxe concrète contenue dans le fichier simproc.atc.
import grammar simproc-in ;
{Programme et blocs}
{==================}
<PROGRAM> = <BLOCK> ;
program (<BLOCK>)
<BLOCK> = <DECL *> <STMT +> ;
block (<DECL *>, <STMT +>)
{Declarations}
{============}
<DECL *> = <DECL *> <DECL> ;
decls-post (<DECL *>, <DECL>)
<DECL *> = ;
decls ()
<DECL> = integer <id> ";" ;
int-decl (<id>)
<DECL> = array <id> "[" <int> "]" ";" ;
array-decl (<id>, <int>)
<DECL> = proc <id> ( val <id> , var <id> ) begin <BLOCK> end ";" ;
proc-decl (<id>.1, <id>.2, <id>.3, <BLOCK>)
{Instructions}
{============}
<STMT +> = <STMT +> ";" <STMT> ;
stmt-list-post (<STMT +>, <STMT>)
<STMT +> = <STMT> ;
stmt-list (<STMT>)
<STMT> = <VAR> ":=" <EXPR> ;
assign (<VAR>, <EXPR>)
<STMT> = call <id> "(" <EXPR> "," <VAR> ")" ;
call (<id>, <EXPR>, <VAR>)
<STMT> = if <EXPR> eq <EXPR> then <STMT +> else <STMT +> fi ;
ifthenelse (<EXPR>.1, <EXPR>.2, <STMT +>.1, <STMT +>.2)
{Expressions et opérateurs}
{=========================}
<EXPR> = <EXPR> <OP> <TERM> ;
bin-expr (<OP>, <EXPR>, <TERM>)
<EXPR> = <TERM> ;
<TERM> = <VAR> ;
used-var (<VAR>)
<TERM> = "(" <EXPR> ")" ;
<EXPR>
<TERM> = <int> ;
constant (<int>)
<OP> = "+" ;
plus ()
<OP> = "-" ;
minus ()
<OP> = "*" ;
mul ()
<OP> = "/" ;
div ()
{variables}
{=========}
<VAR> = <id> ;
simple-var (<id>)
<VAR> = <id> "[" <EXPR> "]" ;
indexed-var (<id>, <EXPR>)
{terminaux}
{=========}
<id> = %ID ;
id () with $id := %ID end with
<int> = %INT ;
number () with $text := %INT end with
La syntaxe concrète décrite dans le fichier simproc.atc est non ambiguë, c'est pourquoi le fichier permettant de résoudre les ambiguïtés, simproc.prio, est vide.
A ce stade, nous sommes en présence de six fichiers de spécification :
Nous pouvons soumettre ces spécifications aux constructeurs concernés. Pour cela, on appellera de nouveau FNC2.
En choisissant l'option D ebmkfnc2, on permet au système de générer un ensemble de fichiers .aux. Ces fichiers contiennent les règles de dépendance des fichiers de spécification, qui se trouvent dans le répertoire spec. Ils permettent d'appeler les processeurs dans le bon ordre.
--------------------------------------------------
debmkfnc2 ? reply (n|y|e|m|help)
--------------------------------------------------
y
ASX
Release 1.15 of (97/08/18 10:35:24)
/local_home/users/vivien/simproc/spec/simproc-base.asx:
Scanner & Parser & Abstract Tree
Listing Output
Release 1.15 of (97/08/18 10:35:24)
/local_home/users/vivien/simproc/spec/simproc-in.asx:
Scanner & Parser & Abstract Tree
Listing Output
OLGA
PPAT
ATC
Release 1.15 of (97/08/18 10:35:24)
/local_home/users/vivien/simproc/spec/simproc.atc:
Scanner & Parser & Abstract Tree
En choisissant l'option K akemkfnc2, on permet au système, de créer le fichier simproc.MKFNC2 en fonction des fichiers .aux. Ce fichier permet l'appel des divers constructeurs.
-------------------------------------------------------
makemkfnc2 ? reply (n|y|e|m|help)
-------------------------------------------------------
y
simproc.MKFNC2:
Pretty Printer char count: 237
-----------------------------
Your simproc.MKFNC2
-----------------------------
application simproc is
ASX simproc-base simproc-base import
end import ;
ASX simproc-in simproc-in import
ASX simproc-base ?
end import ;
ATC simproc simproc import
ASX_FUNC simproc-in ?
end import ;
end application ;
En choisissant l'option C onstruction, on déclenche l'appel des constructeurs sur l'ensemble des spécifications dans le répertoire spec. Le menu boucle sur cette option, ce qui permet à l'utilisateur de corriger les spécifications et relancer les constructions, jusqu'à ce qu'elles soient correctes.
---------------------------------------------------------------------- Construction ? reply (n|m|e|y|s|a|help) ---------------------------------------------------------------------- y
|
|
Project Oscar |
Previous: Analyse lexicale
Web page maintained by Didier Parigot