Implantation de la barrière syntaxique

À revoir entièrement (arbres bornés 2 ? Sexpression ?)
Nous nous intéressons maintenant à l'implantation de la barrière syntaxique.

On peut implanter l'arbre de syntaxe abstraite des expressions booléennes simples à l'aide des Sexpressions:

une constante est tout simplement implantée par le symbole Scheme correspondant,
un opérateur est tout simplement implanté par le symbole Scheme correspondant,
une expression unaire est implantée par une Sexpression ayant deux éléments, la Sexpression implantant l'opérateur et la Sexpression implantant l'opérande.
une expression binaire est implantée par une Sexpression ayant trois éléments, les Sexpressions implantant, dans l'ordre, l'opérande gauche, puis l'opérateur et enfin l'opérande droit.

et nous décidons -- mais nous pourrions faire un autre choix -- que le premier élément de la liste correspond à l'opérande gauche (qui est une expression), que le second élément correspond à l'opérateur et que le dernier élément correspond à l'opérande droit (qui est une expression).

devient (opérandeG opérateur opérandeD)

Remarque: il faut bien comprendre que ceci n'est pas un arbre borné-deux puisque les deux sous-arbres et la racine sont mis sur le même plan: ce n'est qu'une implantation, parmi d'autres, de l'arbre de syntaxe abstraite.

Les définitions des différentes fonctions de la barrière syntaxique s'écrivent alors facilement (nous ne l'étudierons donc pas, nous vous le donnons en annexe).

sexpr-infixe->ebs
Et maintenant, transgressons nos règles!!!

Pour savoir si l'expression booléenne simple exp écrite en infixé, complètement parenthésée, est une expression constante, en utilisant la forme générale que nous avons donnée page ??, nous écririons:

(ebs-exp-cste? (sexpr-infixe->ebs exp))

Mais, rappelons que nous avons implanté l'arbre de syntaxe abstraite avec une Sexpression en prenant, dans le cas d'une expression binaire, comme premier élément l'opérande gauche, comme deuxième élément l'opérateur et comme troisième élément l'opérande droit. Considérons alors le langage expBoolSimple_infixe: quelle que soit sa donnée, la fonction sexpr-infixe->ebs rend la donnée elle-même (on dit que c'est la fonction identité).

Pour savoir si l'expression booléenne simple exp, écrite dans le langage expression_infixe, il suffit donc d'écrire, en traversant la barrière syntaxique:

(ebs-exp-cste? exp)

Par exemple:

;;; exemple d'application de ebs-exp-cste?:

(ebs-exp-cste? '((@non (@v @et @v)) @ou @f)) -> #t

De même, pour afficher une expression en infixé, complètement parenthésée, il suffit de faire afficher, en traversant encore la barrière syntaxique, par l'interprète Scheme, la valeur de l'expression dans l'implantation infixe de la barrière syntaxique.

Retour sur les expressions en préfixé
Dans les paragraphes précédents, nous avons considéré que l'on voulait utiliser plusieurs sortes d'expressions (en infixe, suffixe...) en même temps. Dans la réalité, le plus souvent, on n'utilise qu'une notation et on s'y tient (au moins un certain temps...). Nous avons vu aussi qu'il était alors plus simple d'avoir une implantation de la barrière syntaxique en accord avec la notation retenue. Ainsi, dans l'exemple, nous avions décidé de prendre une notation infixe, aussi avons-nous implanté la barrière syntaxique en utilisant des Sexpressions où l'opérateur est en position centrale. Mais on peut changer d'avis... Si, après avoir décidé d'utiliser une notation infixe, nous décidons de n'utiliser que des expressions préfixe, au lieu d'écrire des convertisseurs d'entrée et de sortie, il y a plus simple, plus sûr et plus efficace: changer l'implantation de la barrière d'abstraction en utilisant une implantation préfixe (et, ainsi, les convertisseurs deviennent inutiles). Voici le source des seules définitions à modifier (la définiton de ebs-binaire-operande-droite restant la même par hazard):

;;; ebs-binaire-operande-gauche : Binaire -> ExprBoolSimple ;;; (ebs-binaire-operande-gauche exp) rend l'expression, opérande gauche de ;;; l'expression donnée (define (ebs-binaire-operande-gauche exp) (cadr exp)) ;;; ebs-binaire-operateur : Binaire -> Operateur2 ;;; (ebs-binaire-operateur exp) rend l'opérateur (principal) de l'expression donnée (define (ebs-binaire-operateur exp) (car exp))

;;; ebs-binaire : ExprBoolSimple * Operateur2 * ExprBoolSimple -> ExprBoolSimple ;;; (ebs-binaire exp1 op exp2) rend l'expression composée ayant comme ;;; opérande gauche exp1, comme opérateur op et comme opérande droit exp2 (define (ebs-binaire exp1 op exp2) (list op exp1 exp2))

Conclusion
Aussi, dans la plupart des cas, nous tricherons:

en prenant un langage complètement parenthésée (i.e. une Sexpression),
en implantant l'arbre de syntaxe abstraite avec la même forme que le langage considéré,
et si nous voulons changer de forme de représentation (infixe, préfixe, postfixe...), nous modifierons carrément l'implantation de la barrière d'abstraction.