# Introduction

Ce didacticiel est destiné aux nouveaux utilisateurs de la Simple Virtual Machine.

Dans ce didacticiel, vous allez manipuler un type de données lié aux conditions.

Le temps de lecture de ce didacticiel est estimé à 15 minutes si les structures de contrôle ont été abordées.

# Mise en place

Pour commencer, créez le canevas de l'application dans le fichier exécutable booleens.svm en utilisant ce code :

    #!/usr/bin/env svm
    DESCRIPTION
    Booleans example
    END
    LOG
    DEBUG "Boolean" STYLE "default"
    PLUGIN "svmcom.so"
    OPTION -s INT size
    PROCESS "application"
    	CODE "main" INLINE
    		:memory BLN/a, BLN/b, BLN/c
    	END
    	MEMORY size
    END

# Qu'est-ce-qu'un booléen ?

Un booléen est la réification d'une condition : cela signifie qu'un booléen est une valeur qui matérialise une condition.

Un booléen ne peut prendre que deux valeurs : vrai ou faux.

# Manipulation des booléens

## Construire une valeur booléenne

Modifiez le code pour obtenir :

    #!/usr/bin/env svm
    DESCRIPTION
    Booleans example
    END
    LOG
    DEBUG "Boolean" STYLE "default"
    PLUGIN "svmcom.so"
    OPTION -s INT size
    PROCESS "application"
    	CODE "main" INLINE
    		:memory BLN/a, BLN/b, BLN/c
    		TRUE -> &a
    		FALSE -> &b
    		? @&size IN &0*5 -> &c
    		:com.message @&a " " @&b " " @&c
    	END
    	MEMORY size
    END

Lancez une première fois l'application avec l'option -s :

    ./booleens.svm -s 3
    TRUE FALSE TRUE

Puis lancez une seconde fois l'application avec une valeur différente pour l'option -s :

    ./booleens.svm -s 7
    TRUE FALSE FALSE

Dans cet exemple, deux manières différentes de construire des booléens sont illustrées : les deux premiers sont constants et valent respectivement vrai et faux, et le dernier est construit à partir du résultat d'une condition.

- Un booléen peut être construit par ses valeurs constantes : `TRUE` ou `FALSE`.
- Un booléen peut également être construit depuis une condition : `?condition`

## Condition booléenne

Vous pouvez maintenant modifier le code :

    #!/usr/bin/env svm
    DESCRIPTION
    Booleans example
    END
    LOG
    DEBUG "Boolean" STYLE "default"
    PLUGIN "svmcom.so"
    OPTION -s INT size
    PROCESS "application"
    	CODE "main" INLINE
    		:memory BLN/a, BLN/b, BLN/c
    		? @&size IN &0*5 -> &a
    		:goto skip :when @&a TRUE
    		:com.message "out of range"
    		0 -> &size
    	:label skip
    		:com.message @&size
    	END
    	MEMORY size
    END

Lancez une première fois l'application avec l'option -s :

    ./booleens.svm -s 3
    3

Puis lancez une seconde fois l'application avec une valeur différente pour l'option -s :

    ./booleens.svm -s 7
    out of range
    0

Cette fois, lorsque le booléen est vrai, l'instruction `:goto` est exécutée et évite l'alternative simple. Dans le cas contraire, l'alternative simple est exécutée, ce qui affiche un message supplémentaire et remet la valeur à l'adresse `&size` à 0.

Lorsqu'une condition doit être lue depuis un booléen, la condition s'écrit : `booleen TRUE`.

## Opérations booléennes

Les booléens peuvent être combinés pour contenir des conditions dont le calcul est plus complexe que celles de base.

Modifiez le code :

    #!/usr/bin/env svm
    DESCRIPTION
    Booleans example
    END
    LOG
    DEBUG "Boolean" STYLE "default"
    PLUGIN "svmcom.so"
    OPTION -s INT size
    PROCESS "application"
    	CODE "main" INLINE
    		:memory BLN/a, BLN/b, BLN/c
    		? @&size IN &0*5 -> &a
    		:goto skip :when (&0+@&size) IN &3*5
    		FALSE -> &a
    	:label skip
    		:com.message @&size ": " @&a
    	END
    	MEMORY size
    END

En utilisant cette commande, lancez maintenant l'application avec différentes valeurs pour l'option -s :

    for i in $(seq 0 10) ; do ./booleens.svm -s $i; done
    0: FALSE
    1: FALSE
    2: FALSE
    3: TRUE
    4: TRUE
    5: FALSE
    6: FALSE
    7: FALSE
    8: FALSE
    9: FALSE
    10: FALSE

L'application renvoie la valeur vraie lorsque les deux conditions (la première vérifie que la valeur `@&size` est entre 0 et 4 inclus, et la seconde entre 3 et 7 inclus) sont vraies !

Puis, transformez ce code pour illustrer une autre opération possible :

    #!/usr/bin/env svm
    DESCRIPTION
    Booleans example
    END
    LOG
    DEBUG "Boolean" STYLE "default"
    PLUGIN "svmcom.so"
    OPTION -s INT size
    PROCESS "application"
    	CODE "main" INLINE
    		:memory BLN/a, BLN/b, BLN/c
    		? @&size IN &0*5 -> &a
    		:goto skip :unless (&0+@&size) IN &8*5
    		TRUE -> &a
    	:label skip
    		:com.message @&size ": " @&a
    	END
    	MEMORY size
    END

Avec une commande shell similaire, lancez l'application avec des valeurs entre 0 et 15 incluses :

    for i in $(seq 0 15) ; do ./booleens.svm -s $i; done
    0: TRUE
    1: TRUE
    2: TRUE
    3: TRUE
    4: TRUE
    5: FALSE
    6: FALSE
    7: FALSE
    8: TRUE
    9: TRUE
    10: TRUE
    11: TRUE
    12: TRUE
    13: FALSE
    14: FALSE
    15: FALSE

Maintenant, la valeur résultante est vraie lorsqu'au moins une des conditions (la première vérifie que la valeur `@&size` est entre 0 et 4 inclus, et la seconde entre 8 et 12 inclus) est vraie.

Les booléens supportent des opérations logiques, exprimables nativement en utilisant des sauts conditionnels.

Il est ainsi possible d'implémenter les opérations de base :

- l'opération "et" dont le résultat est vrai si tous les booléens impliqués dans l'opération sont vrais,
- l'opération "ou" dont le résultat est vrai si au moins un des booléens impliqués dans l'opération est vrai.

Il est également possible d'inverser la valeur d'un booléen, mais cela est rarement nécessaire dans le langage de la machine virtuelle. En effet, les mots-clef `:when` et `:unless` peuvent être interchangés partout où la condition est inversée par rapport au booléen.

# Conclusion

Vous venez de voir comment utiliser les booléens pour créer des conditions complexes.

La réification des conditions est un moyen supplémentaire de réaliser des algorithmes complexes.

Les opérations sur les booléens ne sont pas satisfaisantes en l'état. A ce stade de l'apprentissage, c'est le seul moyen à votre disposition pour réaliser ces opérations. Dans un didacticiel ultérieur, une manière plus concise et plus explicite sera disponible pour réaliser les mêmes opérations.