| LINF1251 - Page des travaux pratiques - Environnement de développement - Syntaxe de Oz |
Cette page donne un aperçu rapide de la syntaxe du langage Oz. La syntaxe présentée n'est pas complète, mais elle décrit la partie du langage utilisée dans ce cours.
La grammaire décrite sur cette page utilise les notations suivantes.
Pour faciliter la lecture, les symboles grammaticaux sont en
italique et en gras, tandis que les symboles du langage Oz
(mots-clés et opérateurs) sont en style télétype.
| Notation | Signification |
|---|---|
| w1 w2 | concaténation de w1 avec w2 |
| w1 | w2 | choix entre w1 et w2 |
| ( w ) | groupe d'expressions régulières |
| [ w ] | expression w en option (zéro ou une fois) |
| { w } | expression w zéro, une ou plusieurs fois |
| { w }+ | expression w une ou plusieurs fois |
Le lexique définit les identificateurs et les constantes écrites dans un programme Oz. Les mots-clés ne sont pas mentionnés.
| Règle | Exemples | ||
|---|---|---|---|
| <variable> | ::= | <upper-case letter> {<alphanumerical>} |
X Ma_variable Agent007
|
| | |
`
{<character>}
`
|
`ceci est une variable`
|
|
| <atom> | ::= | <lower-case letter> {<alphanumerical>} |
f mon_Atome agent007
|
| | |
'
{<character>}
'
|
'ceci est un atome'
|
|
| <integer> | ::= |
[~]
( 0 |
<non-zero digit> {<digit>}
)
|
42 ~17
|
| <float> | ::= |
[~]
{<digit>}+.
{<digit>}
[ (e | E)
[~]
{<digit>}+ ]
|
3.14
6.67e~11
~17.
|
| <string> | ::= |
"
{<character>}
"
|
"ceci est un string"
|
| <oz character> | ::= |
& <character>
|
&a = 97
|
Voici les définitions principales pour les instructions de base du langage.
| <statement> | ::= |
skip
|
| | | <statement> <statement> | |
| | |
<variable>
=
<expression>
|
|
| | |
(
<in statement>
)
|
local
{<declaration>}+
in
<statement>
end
|
|
| | |
if
<expression>
then
<in statement>
{ elseif
<expression>
then
<in statement> }
[ else
<in statement> ]
end
|
|
| | |
case
<expression>
of
<pattern>
[ andthen
<expression> ]
then
<in statement>
{ []
<pattern>
[ andthen
<expression> ]
then
<in statement> }
[ else
<in statement> ]
end
|
|
| | |
{<expression>
{<expression>}
}
|
|
| | |
proc
{<variable>
{<pattern>}
}
<in statement>
end
|
|
| | |
fun
{<variable>
{<pattern>}
}
<in expression>
end
|
|
| | | <exception statement> | <stateful statement> | <functor statement> | |
| <in statement> | ::= |
[
{<declaration>}+
in
]
<statement>
|
| <declaration> | ::= |
<variable>
|
<pattern>
=
<expression>
|
<statement>
|
Les instructions compilables dans l'environnement de développement ont la syntaxe suivante:
| <interactive statement> | ::= | <statement> |
| | |
declare
{<declaration>}+
[in
<statement>]
|
Voici les définitions principales pour les expressions de base du langage.
| <expression> | ::= |
<variable>
|
_
|
| | | <data expression> | |
| | | <unary operator> <expression> | |
| | | <expression> <binary operator> <expression> | |
| | |
(
<in expression>
)
|
|
| | |
local
{<declaration>}+
in
[<statement>]
<expression>
end
|
|
| | |
if
<expression>
then
<in expression>
{ elseif
<expression>
then
<in expression> }
[ else
<in expression> ]
end
|
|
| | |
case
<expression>
of
<pattern>
[ andthen
<expression> ]
then
<in expression>
{ []
<pattern>
[ andthen
<expression> ]
then
<in expression> }
[ else
<in expression> ]
end
|
|
| | |
{
<expression>
{<expression>}
}
|
|
| | |
proc {$
{<pattern>}
}
<in statement>
end
|
|
| | |
fun {$
{<pattern>}
}
<in expression>
end
|
|
| | | <exception expression> | <stateful expression> | <functor expression> | |
| <in expression> | ::= |
[
{<declaration>}+
in
]
[<statement>]
<expression>
|
| <unary operator> | ::= |
~
|
| <binary operator> | ::= |
.
| +
| -
| *
| /
| div
| mod
| ==
| \=
| <
| =<
| >
| >=
| andthen
| orelse
|
Les priorités des opérateurs sont spécifiées ci-dessous.
Les expressions suivantes et les patterns décrivent des structures de données. C'est pour cela qu'ils sont groupés ici.
| <data expression> | ::= |
<atom>
| <integer>
| <float>
| <string>
| <oz character>
| true
| false
| unit
|
| | |
<label>
(
{
[<feature>
:]
<expression>
}
)
|
|
| | |
<expression>|<expression>
|
<expression>
{#<expression>}+
|
[ {<expression>}+ ]
|
|
| <pattern> | ::= |
<variable>
|
_
|
| | |
<atom>
| <integer>
| <float>
| <string>
| <oz character>
| true
| false
| unit
|
|
| | |
<label>
(
{
[<feature>
:]
<pattern>
}
[...]
)
|
|
| | |
<pattern>|<pattern>
|
<pattern>
{#<pattern>}+
|
[ {<pattern>}+ ]
|
|
| | |
( <pattern> )
|
|
| <label> | ::= |
<atom>
| true
| false
| unit
|
| <feature> | ::= |
<atom>
| <integer>
| true
| false
| unit
|
| <exception statement> | ::= |
try
<in statement>
[ catch
<pattern>
then
<in statement>
{
[]
<pattern>
then
<in statement> }
]
[ finally
<in statement> ]
end
|
| | |
raise
<in expression>
end
|
|
| <exception expression> | ::= |
try
<in expression>
[ catch
<pattern>
then
<in expression>
{
[]
<pattern>
then
<in expression> }
]
[ finally
<in statement> ]
end
|
| | |
raise
<in expression>
end
|
| <stateful statement> | ::= |
<expression>
:=
<expression>
|
<expression>,<expression>
|
| | |
class
<variable>
{ <class descriptor> } { <method> } end
|
|
| <stateful expression> | ::= |
{NewCell
<expression>}
|
@<expression>
|
self
|
| | |
class
[$]
{ <class descriptor> } { <method> } end
|
|
| <class descriptor> | ::= |
from
{<expression>}+
|
attr
{<feature>}+
|
| <method> | ::= |
meth
<method head>
<in statement>
end
|
| <method head> | ::= |
<label>
(
{
[<feature>
:]
<variable>
[<=
<expression>]
}
[...]
)
|
L'appel de méthode sur un objet est une instruction dont la syntaxe
correspond à un appel de procédure.
Pour en faire une instruction, il faut remplacer un des champs de la
méthode par $.
Ainsi, les deux instructions suivantes sont équivalentes.
{Objet methode(X Y)}
Y = {Objet methode(X $)}
| <functor statement> | ::= |
functor
<variable>
[ import
{
<variable>
[at
<atom>]
}+
]
[ export
{
[<feature>:]
<variable>
}+
]
define
{<declaration>}+
[in
<statement>]
end
|
| <functor expression> | ::= |
functor
[$]
[ import
{
<variable>
[at
<atom>]
}+
]
[ export
{
[<feature>:]
<variable>
}+
]
define
{<declaration>}+
[in
<statement>]
end
|
Les différents opérateurs utilisés dans Oz sont repris ci-dessous, dans
l'ordre décroissant des priorités.
Les priorités indiquent, par exemple, que
X.1+2 doit se lire
(X.1)+2.
La direction de l'associativité permet, quant à elle, de lire
1+2+3 comme
(1+2)+3 (grouper par la gauche), et
1|2|3 comme
1|(2|3) (grouper par la droite).
| Opérateurs | Associativité |
|---|---|
@ |
à gauche |
. |
à gauche |
~ |
à gauche |
, |
à droite |
* / div mod |
à gauche |
+ - |
à gauche |
# |
multifixe |
| |
à droite |
== \= < =< > >= |
aucune |
andthen |
à droite |
orelse |
à droite |
:= |
à droite |