Dossier complété prêt à imprimer

J'adore ma vie
2026-07-09 15:08:05 +00:00 · 2021-06-06 12:44:11 +02:00
parent ce6bb8027b
commit 7dbc751d39
86 changed files with 2557 additions and 329 deletions
@@ -0,0 +1,16 @@
+    \section{Commande}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Exécution d'une commande
+        \paragraph{Récit : } Exécution d'une commande
+    \paragraph{En tant que : } programmeur avec l'interpréteur LIR
+    \paragraph{Je souhaite : } exécuter une commande
+    \paragraph{Afin de : } obtenir le résultat de cette commande ou une
+                               confirmation de son exécution
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir du fait : } l'interpréteur affiche un invite
+    \paragraph{Alors : } j'entre une ligne de commande
+    \paragraph{Enfin : } j'obtiens le résultat de cette commande ou un retour
+    m'informant du bon déroulé de l'exécution de la commande ou de son échec.
@@ -0,0 +1,15 @@
+    \section{Commande affiche}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } Faire un saut de ligne avec la commande affiche
+	\paragraph{Récit : }  Provoquer le saut de ligne sur la sortie de texte courante
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } que l'interpréteur LIR saute une ligne sur la sortie de texte courante
+	\paragraph{Afin de : } Provoquer un saut de ligne sur cette sortie
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir du fait : } que j'ai une sortie de texte courante
+	\paragraph{Alors : } j'entre la commande affiche
+	\paragraph{Enfin : } l'interpréteur saute une ligne sur la sortie de texte courante
@@ -0,0 +1,15 @@
+    \section{Commande affiche avec une expression}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } Commande affiche (expression)
+	\paragraph{Récit : }  Afficher le contenu d'une expression sur la console de l'interpréteur
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } que l'interpréteur LIR évalue et affiche le contenu de l'expression que l'on lui donne
+	\paragraph{Afin de : } d'afficher le résultat de l'expression en argument
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } l'interpréteur affichant un invite
+	\paragraph{Alors : } j'entre la commande affiche et écrit l'expression dont je veux le résultat affiché
+	\paragraph{Enfin : } l'interpréteur affiche le résultat de l'expression
@@ -0,0 +1,15 @@
+    \section{Commande debut}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } debut
+    \paragraph{Récit : } Réinitialiser l'environnement de l'interpréteur LIR
+    \paragraph{En tant que : } programmeur
+    \paragraph{Je souhaite : } vider l'intégralité du contexte d'exécution
+    \paragraph{Afin de : } obtenir un environnement de travail vierge
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'une session de l'interpréteur LIR
+    \paragraph{Alors : } j'entre la commande \verb|debut|
+    \paragraph{Enfin : } L'interpréteur efface toutes les lignes de programme
+    mémorisées ainsi que tous les identificateurs mémorisés
@@ -0,0 +1,14 @@
+    \section{Commande defs}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Affichages du contexte courant (commande defs)
+    \paragraph{Récit : } Affichages du contexte courant (commande defs)
+    \paragraph{En tant que : } programmeur avec l'interpréteur LIR
+    \paragraph{Je souhaite : } voir toutes les variables définies dans la session courante (identificateur et valeur)
+    \paragraph{Afin de : } connaître le contexte actuel de la session courante de l'interpréteur
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir du fait : } des variables sont définies dans la session courante de l'interpréteur
+    \paragraph{Alors : } je souhaite connaître le contexte actuel en exécutant la commande defs
+    \paragraph{Enfin : } l'interpréteur affiche chaque variable ligne par ligne avec son identificateur et sa valeur
@@ -0,0 +1,17 @@
+    \section{Commande fin}
+
+\subsection*{Récit d'utilisation}
+
+\paragraph{Titre : } Commande fin
+\paragraph{Récit : } Quitter l'interpréteur
+\paragraph{En tant que : } programmeur avec l'interpréteur LIR
+\paragraph{Je souhaite : } quitter l'interpréteur LIR et avoir un message
+m'informant de la fermeture de session
+\paragraph{Afin de : } fermer la session courante de l'interpréteur LIR
+
+\subsection*{Critères d'acceptation}
+
+\paragraph{À partir de : } une session de l'interpréteur LIR ouverte
+\paragraph{Alors : } je souhaite quitter l'interpréteur et fermer la session
+courante en exécutant la commande fin
+\paragraph{Enfin : } le processus courant de l'interpréteur LIR s'arrête
@@ -0,0 +1,16 @@
+    \section{Commande var pour une chaîne de caractères}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande var (Chaine de caractères)
+    \paragraph{Récit : }  Initialiser une chaine de caractère dans variable / Changer sa valeur
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'interpréteur LIR stock une chaine dans une variable
+    \paragraph{Afin de : } pouvoir récupérer/manipuler cette chaine plus tard dans le programme
+
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir du fait : } que j'ai la possibilité de saisir une ligne de commande
+    \paragraph{Alors : } je tape la commande var et met une chaine de caractère entre double guillements comme valeur : var <nomVariable>="<chaine>"
+    \paragraph{Enfin : } l'interpréteur enregistre dans la variable spécifié la chaine de caractère voulue et renvoie la variable suivie de sa valeur (en tant que feed-back)
@@ -0,0 +1,15 @@
+    \section{Commande var pour un entier}
+   \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande var (Entier)
+    \paragraph{Récit : }  Initialiser un entier dans variable / Changer sa valeur
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'interpréteur LIR stock un entier dans une variable
+    \paragraph{Afin de : } pouvoir récupérer/manipuler cet entier plus tard dans le programme
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir du fait : } que j'ai la possibilité de saisir une ligne de commande
+    \paragraph{Alors : } je tape la commande var et met un entier comme valeur :
+    \verb |var <nomVariable>=<entier> |
+    \paragraph{Enfin : } l'interpréteur enregistre dans la variable spécifié l'entier voulu et renvoie la variable suivie de sa valeur (en tant que feed-back)
@@ -0,0 +1,25 @@
+    \section{Expression concaténation sur chaîne de caractères}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Opérateur + sur les chaînes de caractères
+    \paragraph{Récit : } Concaténation de chaînes
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } accoler deux chaînes l'une à la suite de l'autre
+    \paragraph{Afin de : } créer des messages dépendant du contexte d'exécution sur
+    la sortie standard. Représenter une valeur entière par son écriture chiffrée en
+    base 10.
+
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } deux chaînes de caractères ou une chaîne et un entier,
+    en tant qu'identificateurs déclarés ou expressions littérales.
+
+    \paragraph{Alors : } En utilisant une expression de type
+    \verb|var nouvelleChaine = opeGauche + opeDroite|, j'obtiens la concaténation de
+    deux chaînes.
+
+    \paragraph{Enfin : } L'identificateur \verb|nouvelleChaine| contient la chaîne
+    constituée des deux primordiales concaténées. L'interpréteur confirme en affichant
+    la nouvelle valeur ou m'informe d'une erreur. L'opération peut être récursive mais n'est pas commutative. Une concaténation s'effectue toujours par la droite.
@@ -0,0 +1,29 @@
+    \section{Expression arithmétique}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Expression arithmétique
+    \paragraph{Récit : } Calculer à l'aide d'expression arithmétique
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR effectue une
+    opération arithmétique courante (addition, soustraction,
+    multiplication, quotient ou reste d'une division entière)
+    \paragraph{Afin que : } j'en exploite ou vois le résultat
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'une ligne de l'interpréteur ou d'une
+    ligne de programme à mémoriser et d'identificateurs auxquels une
+    valeur aura été affectée préalablement ou de constantes littérales
+    numérique.
+
+    \paragraph{Alors : } j'entre une expression composée de deux
+    opérandes de type entier signé et d'un opérateur.
+    \\ Les opérandes peuvent être :
+    \begin{itemize}
+        \item deux constantes littérales
+        \item deux identificateurs
+        \item une constante littérale et un identificateur
+    \end{itemize}
+    \paragraph{Enfin : } j'obtiens le résultat de l'opération ou un
+    message d'erreur m'informant que l'opération est impossible pour les
+    identificateurs ou constantes littérales saisies.
@@ -0,0 +1,31 @@
+    \section{Expression logique}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Expression logique dans un branchement
+    conditionnel
+    \paragraph{Récit : } Opérations relationnelles sur deux entiers
+                         ou sur deux chaînes de caractères
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR compare deux
+    entiers avec une relation d'ordre ou d'équivalence
+    \paragraph{Afin que : } d'exécuter ou non une branche du code avec
+    l'instruction \verb|si <expression> vaen|
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'une ligne de programme à mémoriser et d'identificateurs auxquels une valeur aura été affectée préalablement
+    ou de constantes littérales de même type.
+
+    \paragraph{Alors : } j'entre une expression composée de deux
+    opérandes de même type et l'interpréteur évalue l'expression.
+    \\ Les opérandes peuvent être :
+    \begin{itemize}
+        \item deux constantes littérales
+        \item deux identificateurs
+        \item une constante littérale et un identificateur
+    \end{itemize}
+
+    \paragraph{Enfin : } si l'expression (condition dans l'instruction)
+    est vraie alors l'exécution continuera à partir du numéro de ligne
+    spécifié par l’étiquette, sinon l'exécution continuera en séquence.
@@ -0,0 +1,35 @@
+    \section{Expression logique}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Expression logique dans un branchement
+    conditionnel
+    \paragraph{Récit : } Opérations relationnelles sur deux chaînes de
+    caractères
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR compare deux
+    chaînes de caractères avec une relation d'ordre ou d'équivalence
+    \paragraph{Afin que : } d'exécuter ou non une branche du code avec
+    l'instruction si
+    \newpage
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'une ligne de programme à mémoriser et d'identificateurs auxquels une valeur aura été affectée préalablement
+    ou de constantes littérales de type chaîne de caractères.
+
+    \paragraph{Alors : } j'entre une expression composée de deux
+    opérandes de type chaîne de caractères et d'un opérateur et l'interpréteur
+    évalue l'expression.
+    \\ Les opérandes peuvent être :
+    \begin{itemize}
+        \item deux constantes littérales
+        \item deux identificateurs
+        \item une constante littérale et un identificateur
+    \end{itemize}
+
+    \paragraph{Enfin : } si l'expression (condition dans l'instruction)
+    est vraie alors l'exécution continuera à partir du numéro de ligne
+    spécifié par l’étiquette, sinon l'exécution continuera en séquence.
+
+\end{document}
@@ -0,0 +1,31 @@
+\documentclass[12pt,a5paper, notitle, oneside]{report}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[french]{babel}
+\usepackage[landscape, top=0.5cm]{geometry}
+\begin{document}
+
+    \chapter*{Récit d'utilisation}
+
+    \paragraph{Titre : } Expression sur chaînes
+    \paragraph{Récit : } Concaténation de chaînes
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR concatène deux chaînes
+    \paragraph{Afin que : } j'en exploite ou vois le résultat
+    \newpage
+
+    \chapter*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'une ligne de l'interpréteur ou d'une
+    ligne de programme à mémoriser et d'identificateurs auxquels une
+    valeur aura été affectée préalablement ou de constantes littérales
+    de type chaînes de caractères.
+
+    \paragraph{Alors : } j'entre une expression composée de deux
+    opérandes de type chaîne de caractères et d'un opérateur.
+
+    \paragraph{Enfin : } j'obtiens le résultat de l'opération ou un
+    message d'erreur m'informant que l'opération est impossible pour les
+    identificateurs ou constantes littérales saisies.
+
+\end{document}
@@ -0,0 +1,15 @@
+\section{Commande efface}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande efface
+    \paragraph{Récit : } Utilisation de la commande efface
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } Supprimer ue ou plusieurs lignes d'un programme
+    \paragraph{Afin de : } Effacer les instructions d'un bloc de code
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } une ou plusieurs lignes de programme mémorisé et leur étiquettes
+    \paragraph{Alors : } on tape la commande: efface <etiquette\_debut> : <etiquette\_fin>
+    \paragraph{Enfin : } l'interpréteur efface les lignes de programme dont le numéro d'étiquette est compris dans la plage, comprise entre etiquette\_debut et etiquette\_fin
@@ -0,0 +1,15 @@
+\section{Commande lance}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande lance sans argument
+    \paragraph{Récit : } Exécuter le programme à partir de l'étiquette la plus petite
+    \paragraph{En tant que : } Programmeur avec l'interpréteur LIR
+    \paragraph{Je souhaite : } Exécuter le programme chargé avec la commande lance
+    \paragraph{Afin de : } obtenir le comportement du programme chargé pour atteindre son objectif
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } lignes d'instructions chargé dans la session courante de l'interpréteur LIR
+    \paragraph{Alors : } lorsque j'entre la commande lance sans arguments et la valide le programme s'exécute à
+                         partir de l'étiquette la plus petite
+    \paragraph{Enfin : } le contexte de l'interpréteur contient le contexte final du programme exécuté
@@ -0,0 +1,16 @@
+ \section{Commande stop}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande stop
+    \paragraph{Récit : } Utilisation de la commande stop
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } Arreter un programme
+    \paragraph{Afin de : } terminer son execution
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir du fait : } Qu'un programme comporte au moins une instruction
+    \paragraph{Alors : } on tape la commande: \verb|<etiquette> stop|
+    \paragraph{Enfin : } À son exécution, le programme s'arrête lorsqu'il a atteint
+                         l'étiquette indiquée.
+			             Puis l'interpréteur affiche de nouveau un invite.
@@ -0,0 +1,14 @@
+\section{Etiquette}
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Étiquettes
+    \paragraph{Récit : } Ordonner les lignes d'un programme avec les étiquettes
+    \paragraph{En tant que : } Programmeur avec l'interpréteur LIR
+    \paragraph{Je souhaite : } ajouter des instruction au programmes dans un ordre précis
+    \paragraph{Afin de : } que les instructions puissent être exécutées dans le bon ordre
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } l'interpréteur LIR et des instructions définies
+    \paragraph{Alors : } lorsque j'entre une instruction précédée d'une étiquette alors celle-ci est enregistrée avec son étiquette pour pouvoir être exécutée plus tard.
+    \paragraph{Enfin : } lorsque le programme est lancé alors les instructions s'exécutent l'ordre des étiquettes.
@@ -0,0 +1,18 @@
+\section{Instruction}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Instructions
+    \paragraph{Récit : } Consulter et modifier le contexte d'exécution
+    \paragraph{En tant que : } programmeur
+    \paragraph{Je souhaite : } faire réaliser des actions par l'interpréteur
+    \paragraph{Afin de : } déclarer des variables, des fonctions, effectuer des
+    sauts conditionnels, des itérations, connaître et manipuler le contexte
+    d'un programme.
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } ligne de commande ou programme
+    \paragraph{Alors : } J'entre une instruction pour effectuer une action précise
+    \paragraph{Enfin : } Le contexte est modifié en fonction de cette instruction.
+    L'interpréteur m'informe en cas d'erreur de syntaxe
@@ -0,0 +1,18 @@
+\section{Instruction entre}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Instruction \verb|entre|
+    \paragraph{Récit : } Affecter une valeur saisie dans l'entrée standard
+    \paragraph{En tant que : } programmeur
+    \paragraph{Je souhaite : } saisir la valeur d'une variable au clavier
+    \paragraph{Afin de : } communiquer avec le contexte de l'interpréteur et le modifier
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } l'invite de commande
+    \paragraph{Alors : } je saisi la commande \verb|entre|, suivie d'un
+        nom de variable, afin d'inviter l'utilisateur à saisir une expression littérale.
+    \paragraph{Enfin : } lorsque la valeur est saisie, elle est affectée
+        à la variable que j'ai déterminée dans le contexte, sous réserve
+        que les types concordent.
@@ -0,0 +1,20 @@
+\section{Instruction vaen}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Instruction \verb|vaen|
+    \paragraph{Récit : } Sauts inconditionnels
+    \paragraph{En tant que : } programmeur
+    \paragraph{Je souhaite : } effectuer un saut vers une ligne
+        spécifique d'un programme.
+    \paragraph{Afin de : } Créer des branchements ou des itérations
+        dans mes programmes.
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } la saisie d'un programme
+    \paragraph{Alors : } j'entre la commande \verb|vaen| suivie du numéro
+        de la ligne où je veux effectuer le saut.
+    \paragraph{Enfin : } lors de l'exécution de
+    l'instruction, le programme ignorera les lignes
+    suivantes et sautera directement à la ligne indiquée.
@@ -0,0 +1,17 @@
+\section{Commande lance à partir d'une étiquette}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande lance <Étiquette>
+    \paragraph{Récit : } Exécuter le programme à partir de l'étiquette argument
+    \paragraph{En tant que : } Programmeur avec l'interpréteur LIR
+    \paragraph{Je souhaite : } Exécuter le programme chargé avec la commande lance <étiquette>
+    \paragraph{Afin de : } obtenir le comportement et objectif du programme chargé
+
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } lignes d'instructions chargé dans la session courante de l'interpréteur LIR
+    \paragraph{Alors : } lorsque j'entre la commande lance sans arguments et la valide le programme s'exécute à
+                         partir de l'étiquette passé en argument
+    \paragraph{Enfin : } le contexte de l'interpréteur contient le contexte final du programme exécuté à partir de l'étiquette spécifiée
@@ -0,0 +1,19 @@
+\section{Instruction procédure}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } Procédure
+	\paragraph{Récit : } Ordonner a l'interpréteur à exécuter des lignes de code à partir de l'étiquette de l'instruction.
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } transférer l'exécution au numéro d'étiquette spécifié.
+	\paragraph{Afin de : } exécuter le programme puis reprendre en séquence une fois le procédure terminée.
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } Plusieurs lignes de code et d'identificateurs déclarés, dont la portée est globale.
+
+	\paragraph{Alors : } En utilisant l'instruction
+    \verb|procedure <etiquette>|
+
+	\paragraph{Enfin : } Alors l'interpréteur va chercher la ligne qui a pour identificateur celui référencé
+						 en étiquette et va l'exécuter jusqu'à'a la fin de la séquence.
@@ -0,0 +1,17 @@
+\section{Instruction retour}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } retour
+	\paragraph{Récit : } Ordonner a l'interpréteur de retourner à la suite de l'instruction qui suit son appel.
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } retourner à la suite de la ligne de code qui a précédé l'appel de procédure.
+	\paragraph{Afin de : } d'exécuter le programme qui allais s'exécuter si l'appel de procédure n'avait pas été fais.
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } Plusieurs lignes de code et a la suite d'une instruction procédure.
+
+	\paragraph{Alors : } En utilisant l'instruction \verb|retour|
+
+	\paragraph{Enfin : } Alors l'interpréteur va chercher la ligne qui suivait l'instruction procédure et va l'exécuter jusqu'à'a la fin de la séquence.
@@ -0,0 +1,22 @@
+\section{Commande liste}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande liste
+    \paragraph{Récit : } Utilisation de la commande liste avec argument
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR affiche affiche
+    toutes les lignes de programme mémorisées dans l'ordre
+    croissant des numéros de ligne dans un intervalle donné.
+    \paragraph{Afin que : } je visualise uniquement les lignes de cet intervalle dans l'ordre croissant.
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } aucune ou plusieurs lignes de programme
+    à mémoriser et de leurs étiquettes et d'un intervalle d'entier passé en argument
+
+    \paragraph{Alors : } j'entre la commande \verb| liste <etiquette_debut>:<etiquette_fin> |
+
+    \paragraph{Enfin : } l'interpréteur affiche toutes les lignes
+    de programme mémorisées, s'il y en a, dans l'ordre croissant de leur
+    étiquette et dont les étiquettes sont situées dans cet intervalle donné.
@@ -0,0 +1,22 @@
+\section{Instruction}
+
+    \subsection*{Récit d'utilisation}
+
+    \paragraph{Titre : } Commande liste
+    \paragraph{Récit : } Utilisation de la commande liste sans argument
+    \paragraph{En tant que : } Programmeur
+    \paragraph{Je souhaite : } que l'Interpréteur LIR affiche affiche
+    toutes les lignes de programme mémorisées dans l'ordre
+    croissant des numéros de ligne.
+    \paragraph{Afin que : } je visualise ces lignes dans leur ordre
+    d'exécution
+
+    \subsection*{Critères d'acceptation}
+
+    \paragraph{À partir de : } d'aucune ou plusieurs lignes de programme
+    à mémoriser et de leurs étiquettes
+
+    \paragraph{Alors : } j'entre la commande \verb| liste |
+
+    \paragraph{Enfin : } l'interpréteur affiche toutes les lignes
+    de programme mémorisées, s'il y en a, dans l'ordre croissant de leur étiquette.
@@ -0,0 +1,16 @@
+\section{Commande charge}
+
+\subsection*{Récit d'utilisation}
+
+\paragraph{Titre : } Commande charge
+\paragraph{Récit : } Chargement d'un programme à partir d'un fichier
+\paragraph{En tant que : } Programmeur avec l'interpréteur LIR
+\paragraph{Je souhaite : }  charger un programme LIR préalablement enregistré dans un fichier
+\paragraph{Afin de : } je puisse réutiliser un programme LIR sans repartir de zéro.
+
+\subsection*{Critères d'acceptation}
+
+\paragraph{À partir du fait : } un fichier contenant un programme LIR sur mon ordinateur
+\paragraph{Alors : } lorsque j'entre la commande charge avec en argument le chemin de ce fichier
+\paragraph{Enfin : } les lignes de codes enregistrées dans le fichier sont chargée dans le
+                     programme pour pouvoir être exécutées et/ou modifiées par l'interpréteur LIR
@@ -0,0 +1,17 @@
+\section{Commande sauve}
+
+\subsection*{Récit d'utilisation}
+
+\paragraph{Titre : } Commande sauve
+\paragraph{Récit : } Sauvegarde d'un programme dans un fichier
+\paragraph{En tant que : } Programmeur dans l'interpréteur LIR
+\paragraph{Je souhaite : } sauvegarder un programme LIR dans un fichier
+\paragraph{Afin de : } Pourvoir reprendre mon travail où je m'étais arrêté
+
+\subsection*{Critères d'acceptation}
+
+\paragraph{À partir du fait : } Qu'un programme (avec des étiquettes) ai été saisi
+\paragraph{Alors : } lorsque j'entre la commande sauve avec en argument le chemin du fichier (dans lequel on souhaite sauvegarder le travail)
+                     sauve <cheminFichier>
+\paragraph{Enfin : } les lignes de codes tapées dans l'interpréteur s'enregistres dans le fichier passé en argument de la commande
+                     pour pouvoir être rechargées plus tard par l'interpréteur LIR avec la commande charge <cheminFichier>
@@ -0,0 +1,19 @@
+\section{Instruction procedure}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } Procédure
+	\paragraph{Récit : } Ordonner a l'interpréteur à exécuter des lignes
+						 de code à partir de l'étiquette de l'instruction.
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } transférer l'exécution au numéro d'étiquette spécifié.
+	\paragraph{Afin de : } exécuter le programme puis reprendre en séquence une fois le procédure terminée.
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } Plusieurs lignes de code et d'identificateurs déclarés, dont la portée est globale.
+
+	\paragraph{Alors : } En utilisant l'instruction \verb|procedure <etiquette>|
+
+	\paragraph{Enfin : } Alors l'interpréteur va chercher la ligne qui a pour identificateur celui référencé
+						 en etiquette et va l'exécuter jusqu'à la fin de la séquence.
@@ -0,0 +1,17 @@
+\section{Instruction retour}
+
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } retour
+	\paragraph{Récit : } Ordonner a l'interpréteur de retourner à la suite de l'instruction qui suit son appel.
+	\paragraph{En tant que : } Programmeur
+	\paragraph{Je souhaite : } retourner à la suite de la ligne de code qui a précédé l'appel de procédure.
+	\paragraph{Afin de : } d'exécuter le programme qui allait s'exécuter si l'appel de procédure n'avait pas été fait.
+
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } Plusieurs lignes de code et à la suite d'une instruction procédure.
+
+	\paragraph{Alors : } j'écris l'instruction \verb|retour|
+
+	\paragraph{Enfin : } Alors l'interpréteur va chercher la ligne qui suivait l'instruction procédure et va l'exécuter jusqu'à la fin de la séquence.
@@ -0,0 +1,19 @@
+\section{Instruction si... vaen}
+	\subsection*{Récit d'utilisation}
+
+	\paragraph{Titre : } Instruction \verb|Si|...\verb|vaen|
+	\paragraph{Récit : } Sauts conditionnels
+	\paragraph{En tant que : } programmeur
+	\paragraph{Je souhaite : } effectuer un saut vers une ligne
+	spécifique d'un programme si la condition est remplie.
+	\paragraph{Afin de : } Créer des branchements ou des itérations
+	dans mes programmes.
+	\newpage
+	\subsection*{Critères d'acceptation}
+
+	\paragraph{À partir de : } la saisie d'un programme
+	\paragraph{Alors : } j'entre la commande \verb|si| suivie de la condition a remplir \verb|vaen| suivie du numéro
+	de la ligne où je veux effectuer le saut.
+	\paragraph{Enfin : } lors de l'exécution de l'instruction, le programme
+	ignorera les lignes suivantes et sautera directement à la ligne
+	indiquée si il valide la condition imposée.
@@ -0,0 +1,60 @@
+
+\title{Résumé de cas d'utilisation --- Éditer une ligne de code} % à remplacer
+
+
+        \subparagraph{Acteurs}
+            Programmeur : Il écrit ou modifie une ligne de code dans un
+            programme à faire exécuter par l'interpréteur.
+
+        \subparagraph{Objectifs}
+            Écrire une une ligne de code dans nouveau programme ou un
+            existant afin d'exécuter ou de sauvegarder ce programme.
+
+        \subparagraph{Pré-conditions}
+                Le curseur est derrière l'invite suivi d'une étiquette correspondant
+                au numéro de la ligne de code à éditer.
+
+        \subparagraph{Post-conditions}
+                Le code source édité est prêt à être exécuté, abandonné ou sauvegardé,
+                selon l'intention du programmeur.
+
+        \subparagraph{Scénario nominal (grandes étapes)}
+            \begin{enumerate}
+                \item Le programmeur écrit une instruction ou commande par ligne de code, en la faisant précéder de son étiquette.
+
+                \item Le programmeur consulte le code déjà écrit à tout moment avec la
+                      commande \verb|liste|. Selon la syntaxe choisie, l'interpréteur
+                      affiche la plage demandée ou la totalité des lignes de code
+                      du programme dans l'ordre croissant des étiquettes.
+
+                \item Le programmeur consulte la liste des identificateurs déclarés et
+                      leurs valeurs en entrant la commande \verb|defs|.
+
+                \item Au besoin, le programmeur efface une ou plusieurs lignes avec la
+                      commande \verb|efface|.
+
+                \item Au besoin, le programmeur efface les lignes de code et identificateurs mémorisés et commence un nouveau code avec la commande \verb|debut|.
+            \end{enumerate}
+
+        \subparagraph{Scénarios d'échec}
+
+            \paragraph{Point 2 du scénario nominal :} Aucune ligne de code n'est écrite ou
+            la plage de code à afficher n'est pas correcte.
+            \begin{itemize}
+                \item L'interpréteur en avise le programmeur au moyen d'un message d'erreur.
+                \item Retour au point 1.
+            \end{itemize}
+
+            \paragraph{Point 3 du scénario nominal :} Aucun identificateur n'a encore été
+            déclaré.
+            \begin{itemize}
+                \item L'interpréteur affiche un message informant le programmeur.
+                \item Retour au point 1.
+            \end{itemize}
+
+            \paragraph{Point 4 du scénario nominal :} La plage de ligne à effacer est
+            incorrecte.
+            \begin{itemize}
+                \item Un message d'erreur en informe le programmeur
+                \item Retour au point 1.
+            \end{itemize}
@@ -0,0 +1,34 @@
+    \subparagraph{Acteurs}
+    Programmeur : il entre une commande à faire exécuter immédiatement par l'interpréteur.
+
+    \subparagraph{Objectifs}
+    Exécuter la commande entrée dans l'interpréteur.
+
+    \subparagraph{Pré-Conditions}
+    L'interpréteur LIR est lancé et le curseur est derrière l'invite.
+
+    \subparagraph{Post-Conditions}
+    La commande est exécutée et un résultat ou un feedback est affiché.
+
+    \subparagraph{Scénario nominal (grandes étapes)}
+        \begin{enumerate}
+            \item Le programmeur écrit derrière l'invite une ligne de commande.
+            \item Le programmeur valide cette commande.
+            \item L'interpréteur effectue une analyse lexico-syntaxique.
+            \item L'interpréteur interprète la ligne de commande.
+        \end{enumerate}
+
+    \subparagraph{Scénarios d'échec}
+        \subparagraph{Point 3 du scénario nominal :} la syntaxe de la ligne écrite est incorrecte.
+        \begin{itemize}
+            \item Un message d'erreur explicite informe le programmeur.
+            \item Retour au point 4 du scénario nominal.
+        \end{itemize}
+
+        \subparagraph{Point 4 du scénario nominal :} la commande conduit à une erreur d'exécution.
+        \begin{itemize}
+            \item Un message d'erreur explicite informe le programmeur.
+            \item Retour au point 4 du scénario nominal.
+        \end{itemize}
+
+%\end{document}
@@ -0,0 +1,118 @@
+    \chapter*{Introduction}
+    \addcontentsline{toc}{chapter}{Introduction}
+    \Large
+    Le projet interpréteur LIR a été réalisé selon un modèle de cycle
+    de vie itératif. Dans ce document des spécifications détaillées du
+    projet seront présentés les fonctionnalités ajoutées à l'interpréteur
+    au cours de chaque itération avec les récits d'utilisation des
+    fonctionnalités ajoutées ou des éléments nécessaires au bon
+    fonctionnement de l'interpréteur LIR.
+
+
+    \large
+    \chapter{Première itération}
+
+    \section*{Contenu de la première itération}
+    Dans cette première itération, l'objectif est d'avoir un
+    prototype de l'interpréteur avec des fonctionnalités de base.
+    Ces premières fonctionnalités sont les commandes et instructions suivantes :
+    \begin{itemize}
+        \item Commande \verb|debut| qui efface toutes les lignes de
+              programme mémorisées ainsi que tous les identificateurs
+              mémorisés.
+        \item Commande \verb|fin| qui quitte l'interpréteur.
+        \item Commande \verb|defs| qui affiche le contexte de
+              l'interpréteur, i.e. affiche la liste des identificateurs
+              définis durant la session avec leur valeur.
+        \item Instruction \verb|affiche| qui évalue la valeur de
+              l'expression et l'affiche sur la sortie texte courante ou
+              alors provoque un saut de ligne sur la sortie texte
+              courante.
+        \item Instruction \verb|var| qui affecte la valeur de
+              l'expression à la variable nommée par l’identificateur.
+    \end{itemize}
+
+
+    \footnotesize
+    \chapter*{Récits d'utilisation proposés lors de l'itération 1}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommande.tex}
+    \newpage
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeDebut.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeFin.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeDefs.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeAffiche.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeAfficheExpression.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeVarChaine.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryCommandeVarEntier.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryConcatenation.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryExpressionLogique.tex}
+    \input{fichiers/specifLaTex/iteration1/userStoryExpressionArithmetique.tex}
+
+    \large
+    \chapter{Deuxième itération}
+    \section*{Contenu de la deuxième itération}
+    Dans cette deuxième itération, l'objectif est d'ajouter des
+    fonctionnalités permettant l'écriture de programmes simple
+    en LIR, à savoir :
+    \begin{itemize}
+        \item Commande \verb|efface| qui efface toutes les lignes
+              de programme dont le numéro d’étiquette est dans la
+              plage comprise entre \verb|<etiquette_debut>| et
+              \verb|<etiquette_fin>|.
+        \item Commande \verb|lance| qui démarre l’exécution d’un
+              programme à partir de son plus petit numéro d’étiquette
+              ou du numéro d'étiquette indiqué par l'utilisateur.
+        \item Commande \verb|liste| qui affiche toutes les lignes de
+              programme mémorisées dans l'ordre croissant des numéros
+              de ligne.
+        \item Instruction \verb|stop| qui arrête l'exécution du programme.
+        \item Instruction \verb|vaen| qui continue l'exécution à partir
+              du numéro spécifié par étiquette.
+        \item Instruction \verb|procedure| qui transfère l'exécution du
+              programme au numéro d’étiquette spécifié et qui reprendra
+              en séquence lorsque la procédure sera terminée.
+        \item Instruction \verb|retour| qui, rencontrée après un appel
+              de procédure, provoque un retour à l'instruction qui suit
+              son appel.
+    \end{itemize}
+
+    \footnotesize
+    \chapter*{Récits d'utilisation proposés lors de l'itération 2}
+    \input{fichiers/specifLaTex/iteration2/userStoryCommandeEfface.tex}
+    \newpage
+    \input{fichiers/specifLaTex/iteration2/userStoryCommandeLance.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryCommandeStop.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryEtiquette.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryInstruction.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryInstructionVaen.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryLanceEtiquette.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryProcedure.tex}
+    \input{fichiers/specifLaTex/iteration2/userStoryRetour.tex}
+    \input{fichiers/specifLaTex/iteration2/userStroryListeArgument.tex}
+    \input{fichiers/specifLaTex/iteration2/userStroryListeVoid.tex}
+
+    \large
+    \chapter{Troisième itération}
+    \section*{Contenu de la première itération}
+    Dans cette troisième itération, l'objectif est de couvrir toutes
+    les fonctionnalités attendues. Ces dernières  concernent la
+    lecture et l'écriture de fichier et l'ajout d'une structure de
+    contrôle à l'interpréteur :
+    \begin{itemize}
+        \item Commande \verb|sauve| qui sauvegarde les lignes de
+              programme dans le fichier texte indiqué en argument.
+        \item Commande \verb|charge| qui charge dans le contexte
+              les lignes de programme sauvegardées dans le fichier
+              texte indiqué en argument.
+        \item Instruction \verb|si... vaen| : si la condition est
+              vraie alors l'exécution continuera à partir du numéro
+              de ligne spécifié par l’étiquette, sinon l'exécution
+              continuera en séquence.
+    \end{itemize}
+
+    \footnotesize
+    \chapter*{Récits d'utilisation proposés lors de l'itération 3}
+    \input{fichiers/specifLaTex/iteration3/userStoryCommandeSauve.tex}
+    \newpage
+    \input{fichiers/specifLaTex/iteration3/userStoryCommandeCharge.tex}
+    \input{fichiers/specifLaTex/iteration3/userStoryInstructionSiVaen.tex}