EXPRESSIONS BOOLEENNES

Instructions du code intermédiaire

(P)B[P/N/Z] $reg, etiquette

positif, négatif, zéro

JMP etiquette

Elles suffisent pour générer du code pour les structures conditionnelles et itératives

Code pour les boucles et IF

On suppose que l’expression booléenne possède un attribut place (lieu) et que les valeurs booléennes sont représentées par un octet qui vaut 1 (vrai) ou 0 (faux).

Première idée: I → if E then I I_{1}.etiquette = nouvelle.etiquette I_{1}.code = E.code ∥ gen(BZ, E.place, ′,′ , I_{1}.etiquette) ∥ I_{2}.code ∥ gen(I_{1}.etiquette )

Pouréviter la possibilité d’avoir plusieursétiquettes sur une instruction il faut ajouter un attribut suit pour l’instruction qui suit une I.

I → if E then I I_{2}.suit = I_{1}.suit I_{1}.code = E.code ∥ gen(BZ, E.place, ′,′ , I.suit) ∥ I_{2}.code

I → I I I_{2}.suit = nouvelle.etiquette I_{3}.suit = I_{1}.suit I_{1}.code = I_{2}.code ∥ gen(I_{2}.suit ) ∥ I_{3}.code

Pareil pour if-then-else

Les Boucles

Code simple pour boucles while et repeat normales

L1 Expression.code
BZ Expression.place, L2
Instruction.code
JMP L1
L2

et

L1
Instruction.code
Expression.code
PBP Expression.place, L1

Le deuxième est plus court et plus efficace! Pourquoi? parce que le test est à la fin:

JMP L2
L1
Instruction.code
L2 Expression.code
PBP Expression.place, L1

est une version du code de while qui est plus efficace (si le nombre moyen d’itérations est supérieur à 1!)

A noter que l’idée promue par Pascal qu’il y a deux types de boucles, (à savoir celles avec test au début et continuation si le test est vrai et celles avec test à la fin et termination si les test est vrai) est erronée. (B)CPL avaient les 4 possibilités.

Evaluation d’expressions

booléennes

Pour les opérateurs de comparaison: E → E op E Prenons le cas ou op est > E_{1}.vrai := nouvelle.etiquette E_{1}.code = E_{2}.code ∥ E_{3}.code ∥ gen(′CMP′, $t, E_{2}.place, ′,′ , E_{3}.place) gen(′BP′, $t, ′,′ , E_{1}.vrai) ∥ gen(′SET′, E_{1}.place, ′,′ , ′0′) ∥ gen(′JMP′, E_{1}.suit) ∥ gen(E_{1}.vrai, ′SET′, E_{1}.place, ′,′ , ′1′)

plus les règles de calcul pour E.suit...

ET et OU sont comme les opérateurs arithmétiques

COMMENT FAIRE MIEUX

• Souvent le résultat d’une expression booléenne complexe est déterminé par son premier opérand

• Souvent le résultat est utilisé immédiatement pour décider le flot d’exécution.

Donc l’idée de deux attributs hérités, l’étiquette à laquelle il faut aller dans le cas d’un résultat vrai (ou faux); Aucun besoin de représentation explicite de la valeur calculée.

exemples

E → E op E E_{1}.code = E_{2}.code ∥ E_{3}.code ∥ gen(′CMP′ , $t, ′,′ , E_{2}.place, E_{3}.place) ∥ gen(′BP′, $t, ′,′ , E_{1}.vrai) ∥ gen(′JMP′, E_{1}.faux)

E → E OU E E_{2}.vrai = E_{1}.vrai E_{3}.vrai = E_{1}.vrai E_{3}.faux = E_{1}.faux E_{2}.faux = nouvelle.etiquette E_{1}.code = E_{2}.code ∥ gen(E_{2}.faux) ∥ E_{3}.code

E → NON E E_{2}.vrai = E_{1}.faux E_{2}.faux = E_{1}.vrai E_{1}.code = E_{2}.code aucun code pour la négation!

Les instructions switch ...

Choisir entre 4 traductions (au moins) • suite de if then ...

• un tableau d’étiquettes (Fortran!) Noter l’instruction

   GO $X, $Y, $Z

• un arbre binaire (interprété ou caché dans le code)

• hâchage selon le nombre et densité des constantes (et si une fourchette de valeurs est possible).