Barrière d'interprétation

Barrières d'interprétation
Si l'on veut évaluer les expressions, encore faut-il savoir à quoi correspondent les terminaux. Ainsi, dans notre exemple, il faut savoir que les symboles @v et @f correspondent aux valeurs de vérité -- mais quelles valeurs de vérité? -- et que les symboles @ou, @et, et @non correspondent respectivement à la disjonction, la conjonction et la négation.

Ainsi doit-on utiliser cinq fonctions, qui constituent la barrière d'interprétation du langage:

;;; faux : -> Booleen ;;; (faux) rend la valeur de vérité « faux »

;;; vrai : -> Booleen ;;; (vrai) rend la valeur de vérité « vrai »

;;; non : Booleen -> Booleen ;;; (non b) rend la négation de b dans le type Booleen

;;; et : Booleen * Booleen -> Booleen ;;; (et b1 b2) rend la conjonction de b1 et de b2 dans le type Booleen

;;; ou : Booleen * Booleen -> Booleen ;;; (ou b1 b2) rend la disjonction de b1 et de b2 dans le type Booleen

Implantations de la barrière d'interprétation

Donnons une première implantation, dans les booléens Scheme:

;;;; Interprétation avec Booleen = #f, #t

(define (faux) #f)

(define (vrai) #t)

(define (faux? b) (not b))

(define (vrai? b) b)

(define (non b) (not b))

(define (et b1 b2) (and b1 b2))

(define (ou b1 b2) (or b1 b2))

Noter l'implantation des opérations qui sont des fonctions qui retournent une fonction.

Une autre implantation, en prenant comme valeurs booléennes les symboles @v et @f:

;;;; Interprétation avec Booleen = @f, @v

(define (faux) '@f) (define (vrai) '@v) (define (faux? b) (equal? b '@f)) (define (vrai? b) (equal? b '@v)) (define (non b) (if (equal? b '@f) '@v '@f)) (define (et b1 b2) (if (and (equal? b1 '@v) (equal? b2 '@v)) '@v '@f)) (define (ou b1 b2) (if (or (equal? b1 '@v) (equal? b2 '@v)) '@v '@f))

Évaluation des expressions constantes
Nous avons spécifié toutes les fonctions nécessaires à l'écriture de la fonction ebs-eval-expr-cste qui a comme spécification:

;;; ebs-eval-expr-cste : ExprBoolSimple -> Booleen ;;; (ebs-eval-expr-cste exp) rend la valeur de vérité de l'expression exp

En effet, voici une définition de cette fonction:

(define (ebs-eval-expr-cste exp) (cond ((ebs-constante? exp) (ebs-eval-constante exp)) ((ebs-unaire? exp) (ebs-eval-unaire exp)) ((ebs-binaire? exp) (ebs-eval-binaire exp)) (else (erreur 'ebs-eval-cste "expression mal formée"))))

;;; ebs-eval-constante : Constante -> Booleen ;;; (ebs-eval-constante cste) rend la valeur de vérité de la constante cste (define (ebs-eval-constante cste) (if (ebs-constante-vrai? cste) (vrai) (faux)))

;;; ebs-eval-unaire : Unaire -> Booleen ;;; (ebs-eval-unaire exp) rend la valeur de vérité de l'expression unaire exp (define (ebs-eval-unaire exp) (let ((operateur (ebs-unaire-operateur exp)) (operande (ebs-unaire-operande exp))) (if (ebs-operateur1-non? operateur) (non (ebs-eval-expr-cste operande)) (erreur 'ebs-eval-unaire operateur "n'est pas un opérateur unaire"))))

;;; ebs-eval-binaire : Binaire -> Booleen ;;; (ebs-eval-binaire exp) rend la valeur de vérité de l'expression binaire exp (define (ebs-eval-binaire exp) (let ((operateur (ebs-binaire-operateur exp)) (operandeG (ebs-binaire-operande-gauche exp)) (operandeD (ebs-binaire-operande-droit exp))) (cond ((ebs-operateur2-et? operateur) (et (ebs-eval-expr-cste operandeG) (ebs-eval-expr-cste operandeD))) ((ebs-operateur2-ou? operateur) (ou (ebs-eval-expr-cste operandeG) (ebs-eval-expr-cste operandeD))) (else (erreur 'ebs-eval-binaire operateur "n'est pas un opérateur binaire")))))

Remarque très importante: noter que cette définition est valable quel que soit le langage utilisé (préfixe, infixe...).