Générateurs

Un générateur permet de définir un squelette de texte paramétré qui est développé par transformation avant que la sémantique des types de données ne soit considérée.

5.3.1.12.1 Définition de générateur Grammaire textuelle concrète

<generator definition> ::=

generator <generator name> ( <generator parameter list> ) <generator text>

endgenerator [ <generator name> ]

<generator text> ::=

[ <generator transformations> ] <properties expression>

<generator parameter list> ::=

<generator parameter> { , <generator parameter> }*

<generator parameter> ::=

{ type | literal | operator | constant }

<generator formal name> {, <generator formal name> }*

<generator formal name> ::=

<generator formal name>

<generator sort> ::=

<generator formal name>

| <generator name>

Un nom <generator name> ou nom <generator formal name> doit uniquement être employé dans une expression

<properties expression> si l'expression <properties expression> figure dans un texte <generator text>.

Dans une définition <generator definition>, tous les noms <generator formal name> de la même catégorie (type, literal, operator ou constant) doivent être distincts. Un nom de la catégorie literal doit être distinct de chaque nom de la catégorie constant appartenant à la même définition <generator definition>.

Le nom <generator name> placé après le mot clé generator doit être distinct de tous les noms de sorte appartenant à la définition <generator definition> mais aussi de tous les paramètres <generator parameter> type de cette définition

<generator definition>.

Une sorte <generator sort> n'est valable que si elle apparaît sous la forme d'une sorte <extended sort> dans un texte

<generator text> et si le nom est soit le nom <generator name> de cette définition <generator definition>, soit un nom

<generator formal name> décrit dans cette définition.

Si une sorte <generator sort> est un nom <generator formal name>, il faut qu'il s'agisse d'un nom défini comme appartenant à la catégorie type.

Le nom <generator name> facultatif figurant après endgenerator doit être le même que le nom <generator name>

indiqué après generator.

Un nom <generator formal name> ne doit pas être employé dans un qualificateur <qualifier>. Un nom <generator name>

ou un nom <generator formal name> ne doit pas:

a) être qualifié; ou

b) être suivi d'une <exclamation>; ou

c) être employé dans une initialisation <default initialization>.

Sémantique

Un générateur nomme une partie de texte qui peut être employée dans les transformations de générateur.

On considère que les textes de transformations de générateur à l'intérieur d'un texte de générateur sont développés au point où le texte du générateur est défini.

Chaque paramètre de générateur comprend une catégorie (type, literal, operator, ou constant) spécifiée par le mot clé type, literal, operator, ou constant, respectivement.

Modèle

Le texte correspondant à une définition du générateur ne se rapporte à la syntaxe abstraite que si le générateur est transformé. Il n'existe pas de syntaxe abstraite correspondante pour la définition du générateur là où la définition est donnée.

Exemple

generator bag(type item) literals empty;

operators

put : item, bag -> bag;

count : item, bag -> Integer;

take : item, bag -> bag;

axioms

take (i,put(i,b)) == b;

take (i,empty) == error!;

count(i,empty) == 0;

count(i,put(j,b)) == count(i,b) + if i=j then 1 else 0 fi;

put(i,put(j,b)) == put(j,put(i,b));

endgenerator bag;

5.3.1.12.2 Transformation de générateur Grammaire textuelle concrète

<generator transformations> ::=

{ <generator transformation> [ <end> ] [ adding ] }+

<generator transformation> ::=

<generator identifier> ( <generator actual list> )

<generator actual list> ::=

<generator actual> { , <generator actual> }*

<generator actual> ::=

<extended sort>

| <literal signature>

| <operator name>

| <ground term>

Si la classe d'un paramètre <generator parameter> est type, le générateur <generator actual> correspondant doit alors être une sorte <extended sort>.

Si la classe d'un paramètre <generator parameter> est literal, le générateur <generator actual> correspondant doit alors être une signature <literal signature>.

Une signature <literal signature> qui est un littéral <name class literal> peut être utilisée comme un générateur

<generator actual> à la seule condition que le nom <generator formal name> correspondant n'apparaisse pas dans les axiomes <axioms>, ou dans la correspondance <literal mapping> de l'expression <properties expression> dans le texte

<generator text>.

Si la classe d'un paramètre <generator parameter> est operator, le générateur <generator actual> correspondant doit alors être un nom <operator name>.

Si la classe d'un paramètre <generator parameter> est constant, le générateur <generator actual> correspondant doit alors être un terme <ground term>.

Si le générateur <generator actual> est un nom <generator formal name>, la classe du nom <generator formal name>

doit alors être la même que la classe correspondant au générateur <generator actual>.

Sémantique

L'utilisation d'une transformation de générateur dans des propriétés étendues ou dans un texte de générateur signifie la transformation du texte identifié par l'identificateur de générateur. Un texte transformé applicable aux littéraux, aux opérateurs et aux axiomes est formé à partir du texte du générateur de la forme suivante:

a) les paramètres réels du générateur sont substitués aux paramètres du générateur; et b) le nom du générateur est remplacé

i) si la transformation de générateur se trouve dans une définition partielle de type ou une définition de syntype, par l'identité de la sorte définie par la définition partielle de type ou par la définition du syntype; autrement

ii) dans le cas de transformation de générateur à l'intérieur d'un générateur, par le nom de ce générateur.

Le texte transformé applicable aux littéraux est le texte transformé à partir des littéraux figurant dans l'expression de propriétés du texte du générateur, le mot clé literals étant omis.

Le texte transformé applicable aux opérateurs est le texte transformé à partir de la liste d'opérateurs figurant dans l'expression de propriétés du texte du générateur, le mot clé operators étant omis.

Le texte transformé applicable aux axiomes est le texte transformé instancié à partir des axiomes figurant dans l'expression de propriétés du texte du générateur, le mot clé axioms étant omis.

Lorsqu'il existe plus d'une transformation de générateur dans la liste des transformations de générateur, les textes transformés applicables aux littéraux (opérateurs et axiomes) sont formés par concaténation du texte instancié applicables aux littéraux (opérateurs, axiomes, respectivement) de tous les générateurs dans l'ordre de leur apparition dans la liste.

Le texte transformé applicable aux littéraux est une liste de littéraux destinée à l'expression de propriétés de la définition partielle de type englobante, de la définition de syntype ou de la définition de générateur qui apparaît avant une liste quelconque de littéraux explicitement mentionnée dans l'expression de propriétés. Autrement dit, si un classement a été spécifié, les littéraux définis par les transformations de générateur seront placés dans l'ordre dans lequel ils ont été transformés et avant tout autre littéral.

Le texte transformé applicable aux opérateurs et aux axiomes est ajouté à la liste d'opérateurs et aux axiomes, respectivement, de la définition partielle de type englobante, de la définition de syntype ou de la définition de générateur.

Lorsqu'un texte transformé est ajouté à une expression de propriétés, il y a lieu d'ajouter, au besoin, les mots clés literals, operators et axioms pour créer la syntaxe concrète correcte.

Modèle

La syntaxe abstraite correspondant à une transformation de générateur est déterminée après transformation. La relation est déterminée à partir du texte transformé, dans le contexte où la transformation <generator transformation> apparaît.

Exemple

newtype boolbag bag(Boolean) adding

operators

yesvote : boolbag -> Boolean;

axioms

yesvote(b) == count(True,b) > count(False,b);

endnewtype boolbag;