Module Declaration


module Declaration: sig  end
Déclarations des différents types utilisés

exception FONCTIONNALITE_NON_IMPLEMENTEE
Exceptions levée lorsque le Parser rencontre une fonctionnalité qui ne sera pas implémentée par le precompilateur

type binOp =
| AND
| OR
| EQDEF
| PLUS
| MINUS
| DIVIDE
| TIMES
| EQUAL
| NOTEQUAL
| LE
| GE
| LT
| GT
| MOD
Définition des opérateurs binaires SMV

type unOp =
| NOT
Définition de l'opérateur unaire "!"
type variable = string * m_type 
Une variable contient un identificateur et son type

type expr =
| Binaire of (expr * binOp * expr)
| Varia of variable (*Expression faisant référence à une variable*)
| Construct of (string * expr) (*Cette expression fait référence à la construction d'un objet. La 'string' est le nom du type de cet objet. L'expr est un Ensemble*)
| Unaire of (unOp * expr)
| Case of (expr * expr) list (*Un case est une liste de couples d'expr : la première est la condition, la deuxième le résultat*)
| Num of int (*Un entier*)
| Chaine of string (*Une chaine*)
| NotDet of expr list (*Un non-détérminisme : une liste d'expr*)
| Ensemble of expr list (*Uniquement utilisé par l'expr.Construct*)
Définition d'une expression

type m_type =
| Boolean
| Enum of expr list (*Type correspondant à une énumération de expr.Chaine ou de expr.Num*)
| Objet of string (*Type utilisé uniquement dans les traitements et dans l'intitulé d'un module SMV. Fait réference à un autre module SMV*)
| Constructeur of expr (*Type utilisé pour définir les variables d'un module SMV construites à partir d'autres modules SMV. L'expr est forcement de type Construct*)
| Defini of expr (*Type utilisé pour différencier les variables 'classiques' d'une variable définie dans la partie DEFINE d'un module SMV*)
| Inconnu
Les différents types que peut avoir une variable
type parametres = variable list 
Liste contenant les paramétres de construction du module
type var_list = variable list 
Liste des variables contenues dans le module SMV : partie VAR

type assign =
| Init of variable (*correspond a init(variable)*)
| Next of variable (*correspond a next(variable)*)
Définition de la structure de l'ASSIGN dans un module SMV
type assign_list = (assign * expr) list 
Liste de tous les assign contenus dans le module SMV : partie ASSIGN
type define_list = variable list 
Liste de tous les define contenus dans le module SMV : partie DEFINE

type liste =
| Var of var_list (*liste correspondant à la partie VAR*)
| Assign of assign_list (*liste correspondant à la partie ASSIGN*)
| Define of define_list (*liste correspondant à la partie DEFINE*)
Définition d'un élément de la liste de déclarations d'un module SMV
type moduleType = string * parametres 
Type regroupant le nom du module et ses paramètres de constructions
type declarations = liste list 
Type regroupant toutes les composantes d'un module

type moduleSMV = {
   modTyp : moduleType; (*Contient le nom du module et son type*)
   declar : declarations; (*Contient entre 1 à 3 Declaration.liste dans l'ordre liste.Var, liste.Assign, liste.Define*)
}
Structure définissant la composition d'un module SMV
type fichier = moduleSMV list 
Liste contenant tous les modules définis dans un fichier