Merge branch 'report' into wip

docs/manual/.gitignore

+# ignores everything but LaTeX files and pdf output
+
+/*
+!.gitignore
+!manual.pdf
+!*.tex
+!/parts/
+!/diagrams/
+!/figs/
+!bibliography.bib
\ No newline at end of file

docs/manual/manual.tex

+\documentclass[a4paper, 12pt]{article}
+\usepackage{ae, lmodern}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[french]{babel}
+\usepackage{graphicx}
+\graphicspath{{figs/}}
+\usepackage{titlesec}
+\usepackage{minted}
+\usepackage{multicol}
+\usepackage{booktabs}
+\usepackage{pdfpages}
+\usepackage{pdflscape}
+\usepackage{lastpage}
+\usepackage{csquotes}
+\usepackage{subcaption}
+\usepackage{hyperref}
+\hypersetup{
+    colorlinks,
+    citecolor=black,
+    filecolor=black,
+    linkcolor=black,
+    urlcolor=black
+}
+\usepackage[a4paper, left=20mm, right=20mm, top=20mm, bottom=30mm]{geometry}
+
+\setlength{\parindent}{0in}
+\titlespacing\section{0pt}{6pt plus 2pt minus 2pt}{6pt plus 2pt minus 2pt}
+\titlespacing\subsection{0pt}{6pt plus 2pt minus 2pt}{6pt plus 2pt minus 2pt}
+
+\title{\vspace{-2,0cm}%
+\includegraphics[width=\textwidth]{../logo.png}~
+\\[2cm]
+\Huge
+\hrulefill\\
+\vspace{1,0cm}
+Prolog avec Truffle et GraalVM\\
+Manuel d'installation et d'utilisation\\
+\vspace{0,6cm}
+\Large
+\hrulefill\\\vspace{2,0cm}
+Projet de semestre 5\\
+I-3\\
+Automne 2019/2020
+\vspace{2.5cm}}
+\author{
+  Martin Spoto \\
+  martin.spoto@edu.hefr.ch\\
+  \\
+  Responsable :\\
+  Frédéric Bapst\\
+  Frederic.Bapst@hefr.ch
+}
+
+\begin{document}
+\maketitle
+
+\pagebreak
+\tableofcontents
+\pagebreak
+
+\section{Introduction}
+Ce document décrit l'installation et l'utilisation du projet "Prolog avec Truffle et GraalVM", pour l'environnement Linux. Le projet fonctionne également sous Windows, mais les étapes d'installation ne sont pas détaillées. 
+
+Ce manuel assume que vous disposez localement d'une copie du projet, et que vous vous trouvez dans le répertoire "code" de celui-ci.
+\section{Installation des dépendances}
+Cette section décrit l'installation des différents pré-requis au fonctionnement du projet.
+\subsection{GraalVM}
+Le projet a été développé avec GraalVM Community Edition 19.2.0.1.\\
+On peut télécharger cette version ici : \href{https://github.com/oracle/graal/releases/tag/vm-19.2.0.1}{https://github.com/oracle/graal/releases/tag/vm-19.2.0.1}. Prenez la version qui correspond à votre système d'exploitation, et décompressez l'archive, par exemple dans \texttt{/usr/lib/graalvm}. Prenez note du chemin d'accès de l'archive décompressée.
+\subsection{Maven}
+Maven est utilisé comme gestionnaire de version. La version 3.6.3 a été utilisée durant le projet, mais les versions proches et futures devraient également fonctionner.\\
+On peut télécharger Maven ici : \href{https://maven.apache.org/download.cgi}{https://maven.apache.org/download.cgi}. Comme pour GraalVM, décompressez l'archive, par exemple dans \texttt{/usr/lib/maven}.
+\section{Préparation de l'environnement}
+Pour préparer les variable d'environnement nécessaires, un script \texttt{envsetup} est fourni. Ce script assume que les chemins de GraalVM et de Maven sont ceux proposés plus haut. Si ce n'est pas le cas, éditez le script avec vos chemins d'installation avant le lancement.
+
+Ce script définit GraalVM comme environnement Java en réglant la variable JAVA\_HOME. Il ajoute également les répertoires bin de GraalVM et de Maven au PATH. Les changements de ce script sont temporaires. En tapant \texttt{exit}, on peut à tout moment sortir de l'environnement (pratique si vous avez plusieurs installations de Java par exemple).
+
+Le script définit également quelques alias qui sont surtout utiles au développement. Ces alias sont consultables dans le fichier \texttt{envaliases}. Toujours pour le développement, le script récupère une copie de la librairie ANTLR utilisée pour générer le parser/lexer (vous aurez besoin pour cela de la commande \texttt{wget}). (D'ailleurs, si un jour vous souhaitez faire exactement ça, un script \texttt{generate\_parser} est également fourni.)
+
+Si tout s'est bien passé, la commande \mintinline{text}{mvn --version} devrait s'effectuer avec succès, et la version Java devrait être celle de GraalVM.
+\section{Compilation du projet}
+Si l'environnement est correctement configuré, alors la compilation s'effectue simplement avec la commande \texttt{mvn package}. Cette opération produit un fichier JAR dans launcher/target et dans language/target. 
+\section{Lancement du projet}
+Si la compilation du projet s'est passée sans encombres, alors on peut lancer le projet à l'aide du script fourni \texttt{prolograal}, en lui donnant comme argument un fichier Prolog, par exemple : \texttt{./prolograal language/tests/02\_variables.pl}, et voilà ! Le projet tourne.
+\section{Notes pour Windows}
+Pour Windows, à part que les scripts ne sont pas utilisables, l'installation et l'utilisation se déroulent exactement de la même manière. Il faut donc simplement configurer la variable JAVA\_HOME et le PATH correctement.
+\end{document}

docs/report/.gitignore

@@ -4,4 +4,7 @@
 !.gitignore
 !report.pdf
 !*.tex
-!/parts/
\ No newline at end of file
+!/parts/
+!/diagrams/
+!/figs/
+!bibliography.bib
\ No newline at end of file

docs/report/bibliography.bib

+@online{SimpleLanguage,
+    author = {GraalVM},
+    title = {SimpleLanguage : A simple example language built using the Truffle API},
+    year = {2015},
+    url = {https://github.com/graalvm/simplelanguage}
+}
+@online{JIProlog,
+    author = {JIProlog},
+    title = {JIProlog},
+    year = {1998},
+    url = {https://github.com/jiprolog/jiprolog/}
+}
+@conference{OneVM,
+    author = {Christian Wimmer},
+    title = {One VM to Rule Them All},
+    year = 2016,
+    organization = {Oracle Labs},
+    address = {Santa Barbara CA},
+    publisher = {PLDI 2016},
+    url = {https://lafo.ssw.uni-linz.ac.at/pub/papers/2016_PLDI_Truffle.pdf}
+}
+@book{WarrenAM,
+    author = {Hassan Aït-Kaci},
+    title = {Warren's Abstract Machine: A Tutorial Reconstruction},
+    publisher = {MIT Press},
+    year = 1991,
+    isbn = {0-262-51058-8}
+}
+@online{WritingTruffle,
+    author = {Cristian Esquivias},
+    title = {Writing a Language in Truffle},
+    year = 2015,
+    url = {https://cesquivias.github.io/tags/truffle.html}
+}
+@techreport{PrologSyntax,
+    type = {Standard},
+    key = {ISO/IEC 13211-1:1995},
+    month = jun,
+    year = 1995,
+    volume = 1995,
+    title = {{Information technology -- Programming languages -- Prolog}},
+    address = {Geneva, CH},
+    author = {ISO},
+    institution = {International Organization for Standardization}
+}
+@online{ANTLRTutorial,
+    author = {Federico Tomassetti},
+    title = {The ANTLR Mega Tutorial},
+    year = 2017,
+    url = {https://tomassetti.me/antlr-mega-tutorial/}
+}
\ No newline at end of file

docs/report/diagrams/techrelationshipdiagram.drawio

+<mxfile host="www.draw.io" modified="2019-12-08T17:19:28.435Z" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36" etag="4RPP1WY6AqyuqpRHVceK" version="12.3.8" type="device" pages="1"><diagram name="Page-1" id="10a91c8b-09ff-31b1-d368-03940ed4cc9e">3VnbcpswEP0apk/tcLEd8+jYSTuZuvU0nrZ5VECAWoEYIYzJ11fAAsaKE7dxKrceD0ZH97NHuws2nHm8fc9RGi2Zj6lhm/7WcBaGbVsj2zaqr+mXDXLhjhog5MSHRj1wSx4wgCagOfFxNmgoGKOCpEPQY0mCPTHAEOesGDYLGB3OmqIQK8Cth6iKfiO+iAC1TLOv+IBJGMHU0zFU3CPvZ8hZnsB8hu0E9aepjlE7FrTPIuSzYgdyrgxnzhkTzV28nWNacdvS1vS7PlDbrZvjRBzT4YE/rD5fFsvFehHE6wtP3BWztzDKBtEc+JBmRvTrEtYsypaneqe4GssynMsiIgLfpsiragupDIlFIqZQDaNiLvD24HKtjgQpLsxiLHgpm0CHUcsz6Mppy8WOlVpuox0DTQBDIIywG7onR94AP7/Bla1wteZ5EEiCdHM1GZ8ZVZajcJULQkmmcoV9eRyhyLiIWMgSRK969LJn05Slvs1HxlLg8AcWogTfgnLBhgxLFnn5ver/btwW72C4urDYDkollJq1Vgt82i5yPyznHn6CEOBDIB5i8ZzGVDtzTJEgm+E6Tm+1kWK1QG4sIRIz5o4xM3VYT4MVpjqtoB6dWZpS4smpWSIrbtAGvczjVL5GjkdnlISJxO6ZECw+jStyhl67i367rsh9xBV18fb0qr44rGqc1BfBa3m7WKvQz8BNjY48IK7OA6J6qWviRQRzCa44oyzUHpD3kxfL0R6R1ewlbESf1D9TriU0n1C74yO1O3mhdqHrihG5wr4JC4JMzrtvp26GPzfdWA0In9Yfv2gX+V7WqV/jE4WoFeJZ7ReaoGkOJO+C1282La9nSautnVZLFaDXB0ydcXIQJfug+fpxcvovxMmpYrYl2lQZj2aB29O9HHGkXeGq55C7qxXu5aLzElnO9epdW17oHqn3A4b/O3p3FSPezKQ7N/0qradv0O5T1Jnlh2dwBNQ3gf/Xs3/7vvlZDY91arhd5aMPN7WQszIRaIvPNV15RSHLYv+2vEmu+78knKtf</diagram></mxfile>
\ No newline at end of file

docs/report/parts/Ameliorations.tex

+\documentclass[../report.tex]{subfiles}
+\begin{document}
+\section{Améliorations possibles}
+Cette section donne quelques améliorations possibles du projet, en discutant de la faisabilité technique et de l'implémentation de chacune.
+\subsection{Optimisations et intégration plus forte à Truffle}
+Le moteur est actuellement très peu optimisé (pour ne pas dire pas optimisé du tout...). Il y a beaucoup d'améliorations possibles à beaucoup d'endroits du projet, mais le principal serait d'améliorer le processus de résolution.
+\subsubsection{Améliorations du noeud de résolution}
+Dans sa version actuelle, chaque noeud de l'arbre de preuve crée deux copies de chaque clause potentiellement unifiable avec le but courant. En parlant de celui-ci, son état est également sauvegardé (ce qui produit des ajouts de l'état des variables à des piles) et restoré une fois pour chaque clause potentielle, puis une fois pour chaque clause unifiable... Les clauses sont également unifiées au but courant deux fois, une fois pour les filtrer, puis une fois pour mettre l'état correct des variables.
+
+Il est évidemment possible de faire mieux. Une piste serait par exemple de garder l'état du but courant en mémoire pour chaque clause, plutôt que d'oublier son état et de le restaurer à l'aide d'une nouvelle unification plus tard.
+\subsubsection{Amélioration du processus de résolution}
+De manière plus générale, le processus de résolution s'appuie actuellement sur la pile d'appels, ce qui limite les possibilités de récursion à la taille de ladite pile. On pourrait simuler le comportement à l'aide d'une boucle et d'une pile externe pour enlever cette limite.
+
+Mais il faudrait d'abord améliorer l'intégration avec Truffle, et vérifier les performances, car Truffle est capable de faire de la \textit{Tail Call Optimization}\footnote{\href{https://cesquivias.github.io/blog/2015/01/15/writing-a-language-in-truffle-part-4-adding-features-the-truffle-way/\#tail-call-optimization-in-truffle}{https://cesquivias.github.io/blog/2015/01/15/writing-a-language-in-truffle-part-4-adding-features-the-truffle-way/\#tail-call-optimization-in-truffle}} et est donc capable de potentiellement enlever la limitation de la pile d'appels sans que l'on doive nous même faire le changement.
+\subsubsection{Intégration plus forte avec Truffle}
+Le projet s'appuie finalement très peu sur les fonctionnalités de Truffle. Très peu de changements seraient requis pour s'en passer complètement. Cela veut également dire que l'on ne profite pas du tout des apports en vitesse promis par Truffle.
+
+Une piste d'utilisation de Truffle est dans le mécanisme de spécialisations : on fournit plusieurs versions d'une même fonction avec des arguments différents, et Truffle se charge d'appeler la bonne (un peu comme la surcharge de méthodes, mais avec moins de coût à l'exécution grâce à la compilation partielle). Cette approche est fondamentalement différente de celle actuellement utilisée. L'implémentation actuelle est sous cette forme : une classe représentant un certain composant de Prolog contient les différentes actions possibles pour ce composant, par exemple l'unification. L'approche Truffle serait la suivante : une classe représentant une action, par exemple l'unification, et plusieurs méthodes représentant la réalisation de cette opération pour les différents types.
+\subsection{Support de l'interopérabilité avec Truffle}
+Truffle propose une API pour faciliter l'interopérabilité entre différents langages de programmation. Cette API se base sur le principe de messages, indiquant les fonctionnalités d'un certain objet. Par exemple, un objet peut avoir le message \texttt{executable} pour indiquer qu'il peut être exécuté (comme une méthode, ou un prédicat par exemple dans notre cas).
+
+La première étape pour rendre notre langage interopérable serait d'étudier la partie \textit{component} du projet de démonstration \sl{} (cf. section \ref{subsec:part1handling}). Cette partie avait été volontairement mise de côté, mais elle sert à rendre notre langage ajoutable en tant que plugin à GraalVM, afin de pouvoir l'utiliser dans d'autres langages et pas uniquement en version \textit{standalone}. 
+
+On pourrait ensuite hypothétiquement utiliser le terminal multi-langages de GraalVM pour définir des prédicats en Prolog et les exécuter dans un environnement Java. Mais cela nécessite également que notre implémentation utilise correctement les fonctionnalités de Truffle, ce qui n'est pas le cas actuellement. Il faudrait donc d'abord améliorer l'intégration avec Truffle pour ensuite pouvoir proposer l'interopérabilité.
+\subsection{Support du prédicat cut}
+Le support du parsing du prédicat peut s'ajouter très facilement. Son comportement, un peu moins... Pour rappel, le cut empêche la remise en question de ce qui le précède, y compris le prédicat qui l'a introduit. Pour l'implémenter, il faudrait donc regarder au moment où on remplace le but courant par le corps de la clause, si elle contient un cut. Ensuite, il faudrait se rappeler de si ce cut a été exécuté ou non (il peut y avoir un échec avant qu'on y arrive). Si ce cut a été exécuté, et qu'il y a un échec après, alors on doit retourner jusqu'au prédicat l'ayant introduit en retournant des échecs même s'il reste d'autres branches possibles. Le prédicat l'ayant introduit doit également retourner un échec. La principale difficulté serait donc de gérer correctement la sauvegarde de qui a introduit le cut, et d'être capable de remonter l'information dans la pile d'appels qu'il faut retourner jusqu'à ce point. 
+\subsection{Support d'autres prédicats/de la librairie standard}
+Avec l'infrastructure mise en place, l'ajout de la plupart des prédicats simples comme par exemple \texttt{select} est facile. Certains prédicats pourraient cependant poser problème, comme par exemple ceux permettant d'ajouter/enlever dynamiquement des clauses, \texttt{assert} et \texttt{retract}. L'ajout ou la suppression en eux-mêmes ne poseraient pas trop de problèmes, vu qu'il est trivial d'ajouter des éléments à la liste des clauses du programme si l'on possède une référence vers le contexte. Par contre, cela pourrait poser des problèmes avec la fonctionnalité \texttt{redo}, vu que l'arbre de preuve pourrait contenir de nouvelles branches qui n'étaient pas là lors de la précédente descente. Il faudrait donc porter une attention particulière à la correction de la sauvegarde de la descente, ou alors interdire la possibilité de modifier un prédicat en cours d'utilisation...
+\end{document}
\ No newline at end of file

docs/report/parts/Annexes.tex

+\documentclass[../report.tex]{subfiles}
+\begin{document}
+\section{Annexes}
+\subsection{Lien du projet}\label{subsec:projectlink}
+Le projet est disponible sur le GitLab de l'école à l'adresse suivante :\\
+\href{https://gitlab.forge.hefr.ch/frederic.bapst/prolog-truffle}{https://gitlab.forge.hefr.ch/frederic.bapst/prolog-truffle}\\
+(une demande d'accès à monsieur Bapst est nécessaire)
+\subsection{Librairies utilisées}
+Cette section liste les différentes librairies nécessaires au fonctionnement du projet.
+\subsubsection*{JLine3}
+JLine est une librairie open source permettant de faciliter la gestion du terminal et de l'entrée utilisateur. Elle est utilisée jusqu'à la phase 2.\\
+Lien : \href{https://github.com/jline/jline3}{https://github.com/jline/jline3}
+\subsubsection*{ANTLR}
+ANTLR est la librairie open source utilisée pour la réalisation du parser et du lexer. Elle a été utilisée durant tout le projet.\\
+Lien : \href{https://github.com/antlr/antlr4}{https://github.com/antlr/antlr4}
+\subsubsection*{JUnit}
+JUnit est la librairie open source utilisée pour la réalisation des tests unitaires.\\
+Lien : \href{https://github.com/junit-team/junit5/}{https://github.com/junit-team/junit5/}
+\subsubsection*{Suite de librairies GraalVM et Truffle}
+Truffle et les autres librairies de GraalVM sont utilisées pour l'implémentation du langage. Elles sont open source.\\
+Lien : \href{https://github.com/oracle/graal}{https://github.com/oracle/graal}
+\renewcommand{\thesubsection}{\Alph{subsection}}
+\setcounter{subsection}{0}
+\includepdf[angle=90, offset=2.1cm -0.1cm, pagecommand=\subsection{Planning}\label{subsec:planning}]{../../specs/planning.pdf}
+\includepdf[pages={2}, offset=0 -2.5cm, pagecommand=\subsection{Manuel d'installation et d'utilisation}\label{subsec:manual}]{../../manual/manual.pdf}
+\includepdf[pages={3-}]{../../manual/manual.pdf}
+\end{document}
\ No newline at end of file

docs/report/parts/Approche.tex

 \documentclass[../report.tex]{subfiles}
 \begin{document}
 \section{Approche et méthodologie}
+Cette section décrit la méthodologie suivie pour le projet ainsi que l'approche initiale utilisée pour démarrer le projet.
 \subsection{Gestion du projet}
-\subsection{Phases du projet}
+Le projet suit un planning établi préalablement, basé sur le cahier des charges, et des séances hebdomadaires avec le responsable de projet sont tenues afin de contrôler le bon déroulement de celui-ci. Un procès-verbal de chaque séance est rédigé, afin de garder une traces des décisions et constatations faites lors des séances. Le planning est disponible en annexe (annexe \ref{subsec:planning}).
+
+Pour la partie technique, un répertoire du logiciel de gestion de versions \textit{Git} est utilisé pour gérer les fichiers du projet. Le répertoire utilise principalement deux branches : la branche "master" contenant le dernier prototype fonctionnel du projet, et la branche "wip" contenant les dernières fonctionnalités, potentiellement encore en cours d'implémentation ou non testées. Sur la branche "master", des "tags" sont utilisés pour marquer les étapes clés du projet. Un lien vers le répertoire du projet est disponible en annexe (\ref{subsec:projectlink}).
+\subsection{Phases du projet}\label{subsec:projectPhases}
+Sur la base du cahier des charges, le projet a été découpé en trois phases principales. Ces phases correspondent à des paliers de fonctionnalités à atteindre, dans le but d'obtenir un prototype fonctionnel à la fin de chacune de ces phases. Ces phases sont décrites en détail dans le cahier des charges disponible en annexe, mais un rappel des différents objectifs de chaque phase sera disponible avant leur section dédiée plus loin dans ce rapport.
+
+En résumé, les phases du projet sont les suivantes :
+\begin{enumerate}
+    \item Fonctionnalités de base : parsing de faits simples, sans variables
+    \item Ajout du support des variables pour ces faits
+    \item Ajout du support des clauses complexes et des listes
+\end{enumerate}
 \subsection{Démarrage du projet}
+Le projet a été démarré en énumérant les connaissances requises pour celui-ci. On en trouve deux principales : l'utilisation de Truffle et l'implémentation d'un interpréteur Prolog.
+
+Pour l'utilisation de Truffle, le point de départ est principalement le langage de démonstration fourni en tant que documentation officielle, SimpleLanguage, qui est une implémentation complète d'un langage de programmation fictif en utilisant Truffle. Différents articles de blogs donnent également une bonne base pour se lancer dans l'implémentation. Ces articles sont listés dans la section suivante.
+
+Pour l'implémentation d'un interpréteur Prolog, le choix a été fait d'étudier les différentes manières existantes, mais de quand même repartir de zéro, en gardant uniquement la "philosophie" de certaines implémentations, pas de base de code. Les différents articles, publications scientifiques et implémentations existantes servant de référence sont listés dans la section suivante.
 \subsection{Littérature et références}
-\subsection{Implémentations existantes}
+Cette section liste les différentes références servant de base et de guide au projet.
+\subsubsection{Utilisation de Truffle}
+\begin{itemize}
+    \item \cite{SimpleLanguage} : Projet de démonstration officiel utilisant Truffle
+    \item \cite{OneVM} : Conférence Oracle sur l'utilisation de Truffle et GraalVM
+    \item \cite{WritingTruffle} : Tutoriel sur l'implémentation d'un langage avec Truffle
+\end{itemize}
+\subsubsection{Implémentation d'un interpréteur Prolog}
+\begin{itemize}
+    \item \cite{WarrenAM} : Livre décrivant une implémentation abstraite possible d'un moteur Prolog
+    \item \cite{JIProlog} : Projet open source implémentant un moteur Prolog en Java
+\end{itemize}
+\subsubsection{Autres}
+\begin{itemize}
+    \item \cite{PrologSyntax} : Référence officielle pour la syntaxe Prolog
+    \item \cite{ANTLRTutorial} : Tutoriel sur l'utilisation de ANTLR
+\end{itemize}
 \end{document}
\ No newline at end of file

docs/report/parts/Conclusion.tex

 \documentclass[../report.tex]{subfiles}
 \begin{document}
 \section{Conclusion}
-\section{Annexes}
+Ce rapport touche à sa fin. Il est temps de faire le point sur le travail réalisé, au travers d'une comparaison avec les objectifs du projet, et de donner un ressenti personnel sur le projet et son déroulement.
+\subsection{Atteinte des objectifs}
+Les fonctionnalités retenues à la section \ref{subsec:projetobjectives} ont toutes été implémentées avec succès. Les fondations pour certains objectifs optionnels également, aux travers des prédicats intégrés \texttt{var} et \texttt{write}, et une gestion basique des exceptions avec une erreur en cas de prédicat inconnu. Les objectifs ayant été fixés au début du projet sont donc atteints.
+
+Il reste un point noir : le projet s'appelle "Prolog avec Truffle et GraalVM", mais au final, c'est plutôt "Prolog en Java"... Ce n'est cependant pas si grave, vu que le projet laisse de bonnes fondations pour un éventuel approfondissement, et que cette étape était nécessaire pour ensuite intégrer plus profondément Truffle. De plus, l'objectif principal du projet était bien de voir s'il est possible d'implémenter un langage de programmation logique avec Truffle, et nous pouvons maintenant répondre de manière affirmative à cette question.
+\subsection{Conclusion personnelle}
+J'ai eu du plaisir à réaliser ce projet. J'ai appris beaucoup de choses sur le fonctionnement interne de Prolog et de manière plus générale sur le fonctionnement d'un interpréteur de langage. Le projet s'est bien déroulé, étant resté dans les temps prévus initialement. Je regrette juste un peu de ne pas avoir eu plus de temps pour creuser l'intégration avec Truffle au cours du projet, car il aurait été très intéressant d'essayer d'optimiser l'interpréteur après l'avoir écrit.
+
+Au niveau de la gestion de l'implémentation, il aurait peut-être fallu planifier un peu mieux les différentes phases en pensant un peu plus au futur de chaque fonctionnalité dans le projet final, car je me retrouvais souvant à devoir presque totalement défaire ce qui avait été fait précédemment pour intégrer les nouvelles fonctionnalités (comme on peut le constater particulièrement entre la phase 2 et 3). 
+
+Mais de manière globale, je suis content d'avoir réalisé ce projet et satisfait de son résultat. Je remercie mon superviseur monsieur Frédéric Bapst pour son accompagnement le long de ce projet, ses conseils avisés et son oeil d'aigle pour les fautes de programmation(et d'orthographe !).
+\subsection*{Déclaration d'honneur}
+\textit{Je, soussigné, Martin Spoto, déclare sur l’honneur que le travail rendu est le fruit d’un travail
+personnel. Je certifie ne pas avoir eu recours au plagiat ou à toute autre forme de fraude.
+Toutes les sources d’information utilisées et les citations d’auteur ont été clairement
+mentionnées.}
+\vspace{2cm}
 \end{document}
\ No newline at end of file

docs/report/parts/Glossaire.tex

+\documentclass[../report.tex]{subfiles}
+\begin{document}
+\section{Glossaire}\label{sec:glossary}
+\subsection*{ANTLR}
+Ensemble de librairies utilisées pour la génération du parser et du lexer.
+\subsection*{Deque}
+Structure de données supportant l'insertion et la suppression efficace au début et à la fin.
+\subsection*{GraalVM}
+Plateforme supportant Truffle. Contient une JVM.
+\subsection*{Java}
+Langage de programmation utilisé pour le projet et ses librairies.
+\subsection*{Java Virtual Machine (JVM)}
+Machine virtuelle permettant l'exécution de programmes Java.
+\subsection*{Maven}
+Gestionnaire de dépendances et de cycle de développement.
+\subsection*{SimpleLanguage}
+Projet de démonstration utilisant Truffle et GraalVM.
+\subsection*{Stack (pile)}
+Structure de données représentant une pile : le dernier élément inséré est le premier élément qui ressort.
+\subsection*{Truffle}
+Ensemble de librairies utilisant GraalVM pour fournir des fonctionnalités d'implémentation de langages.
+\subsection*{arbre de preuve}
+Arbre créé en suivant les règles logiques d'un programme.
+\subsection*{arité}
+Nombre d'arguments d'une structure Prolog.
+\subsection*{backtracking}
+Technique de programmation basée sur l'essai systématique de toutes les possiblités.
+\subsection*{clauses}
+En Prolog, décrit une relation logique. Il existe deux types de clauses : les clauses simples, appelées faits, et les clauses composées.
+\begin{itemize}
+    \item Un fait est de la forme : \mintinline{Prolog}{fact.}
+    \item Une clause composée est de la forme : \mintinline{Prolog}{head :- rule1, rule2.}
+\end{itemize}
+\subsection*{compilateur à la volée}
+Technique permettant de recompiler des bouts de code de manière dynamique lors de l'exécution du programme, pour les rendre plus performants.
+\subsection*{contexte}
+Contexte de l'application, contenant des informations sur les clauses et sur l'environnement du programme. Dans le projet, le contexte peut désigner deux classes :
+\begin{itemize}
+    \item La classe \texttt{ProloGraalRuntime}, qui représente le contexte d'exécution et contient les clauses du programme
+    \item La classe \texttt{ProloGraalContext}, qui contient le contexte globale avec des références vers la sortie et l'entrée standards du programme
+\end{itemize}
+\subsection*{faits}
+Clause Prolog de la forme : \mintinline{Prolog}{fact.}.
+\subsection*{fichier de grammaire}
+Fichier contenant du code compréhensible par ANTLR.
+\subsection*{foncteur}
+Désignateur d'une structure Prolog. Dans la structure \mintinline{Prolog}{a(b, c)}, \texttt{'a'} est le foncteur.
+\subsection*{framework}
+Ensemble de librairies et autres composants.
+\subsection*{interpréteur}
+Peut désigner deux choses :
+\begin{itemize}
+    \item Un interpréteur de langage, qui lit un code source et se charge de l'exécuter (sans le compiler).
+    \item L'interpréteur Prolog, qui est une interface en ligne de commande permettant d'effectuer des requêtes sur un programme Prolog.
+\end{itemize}
+\subsection*{lexer}
+Composant chargé de lire un fichier source, et de créer à partir des caractères des unités compréhensibles pour le parser.
+\subsection*{librairie}
+Ensemble de classes externes réalisant une ou plusieurs fonctionnalités spécifiques.
+\subsection*{liste}
+En Prolog, désigne une structure de la forme \mintinline{Prolog}{[a,b,c | d]}. Une liste possède possiblement une queue, ou \textit{tail} en anglais, qui désigne l'élément à la fin de celle-ci.
+\subsection*{machine virtuelle}
+Couche logicielle permettant l'interprétation d'un langage de plus haut niveau.
+\subsection*{main}
+Fonction principale d'un programme.
+\subsection*{open source}
+Projet dont le code source est disponible publiquement.
+\subsection*{parser}
+Composant chargé de donner un sens aux jetons créés par le lexer, afin de créer des structures de plus haut niveau.
+\subsection*{pattern de développement}
+Patron donnant une réalisation standard d'un composant.
+\subsection*{requête}
+Question posée à l'interpréteur Prolog.
+\subsection*{structure}
+En Prolog, structure de forme \mintinline{Prolog}{a(b, c)}.
+\subsection*{termes}
+En Prolog, mot générique désignant les autres unités de données (structures, variables, etc...).
+\subsection*{unification}
+Mécanisme permettant de rendre deux termes logiques identiques.
+\subsection*{variables}
+En Prolog, représente une inconnue logique, capable de prendre une valeur lors de l'unification.
+\end{document}
\ No newline at end of file

docs/report/parts/Interpreteur.tex

-\documentclass[../report.tex]{subfiles}
-\begin{document}
-\section{Interpréteur simple}
-\subsection{Concepts et objectifs}
-\subsection{Phase 1}
-\subsection{Phase 2}
-\subsection{Phase 3}
-\subsection{Références}
-\end{document}
\ No newline at end of file

docs/report/parts/Introduction.tex

 \documentclass[../report.tex]{subfiles}
 \begin{document}
 \section{Introduction}
+\textit{Prolog avec Truffle et GraalVM} est un projet de semestre réalisé durant le semestre d'automne 2019-2020. Ce rapport contient une trace du déroulement, des choix et des problèmes rencontrés et résolus au fil du projet.
 \subsection{Contexte}
 GraalVM est une machine virtuelle universelle basée sur la \textit{Java Virtual Machine} conçue pour permettre l'interprétation à haute performance de n'importe quel langage de programmation, pour autant qu'un interpréteur pour ce langage soit disponible.  Truffle est le nom du framework permettant l'implémentation en Java d'un tel interpréteur.
 
 Des interpréteurs sont disponibles pour de nombreux langages, tels que JavaScript, Python, Ruby et même C et C++, mais il n'existe actuellement aucun interpréteur pour le langage de programmation logique Prolog.
 
-Le but de ce projet est donc de réaliser cet interpréteur.
-\subsection{Objectifs du projet}
+Le but de ce projet est donc de réaliser cet interpréteur, afin de prouver la faisabilité technique de l'implémentation d'un langage de programmation logique sur cette plateforme.
+\subsection{Objectifs}\label{subsec:projetobjectives}
+L'objectif principal du projet est de fournir un interpréteur pour le langage Prolog basé sur GraalVM et Truffle. Cependant, en raison des contraintes temporelles du projet, implémenter la totalité du langage Prolog n'est pas réalisable. Un sous-ensemble de fonctionnalités jugées "de base" a donc été sélectionné. Les fonctionnalités retenues sont les suivantes :
+\begin{itemize}
+    \item Gestion de termes simples et composés
+    \item Gestion de clauses comprenant des appels récursifs
+    \item Gestion des variables
+    \item Gestion de la notation simplifiée pour les listes
+    \item Unification de termes, variables
+    \item Gestion de la résolution par \textit{backtracking}
+    \item Gestion des requêtes depuis la ligne de commande
+\end{itemize}
+Un certain nombre de fonctionnalités sont également retenues si l'implémentation s'avère plus rapide ou plus simple que prévue. Ces fonctionnalités sont listées sans ordre de priorité ci-dessous :
+\begin{itemize}
+  \item Gestion de calculs avec is/2
+  \item Opérateur "!" (\textit{cut})
+  \item \textit{assert} et \textit{retract}
+  \item Gestion des exceptions
+  \item Traceur de résolution
+  \item Opérateurs mathématiques et logiques usuels (+ - * / = < >)
+  \item Librairie standard, I/O
+  \item Profiter de GraalVM/Truffle pour fournir une interface avec d'autres langages
+  \item Profiter de GraalVM/Truffle pour fournir un débogueur
+\end{itemize}
+\subsection{Déroulement}
+Le projet a été découpé en 4 phases clés :
+\begin{enumerate}
+    \setcounter{enumi}{-1}
+    \item Analyse et prise en main des technologies
+    \item Version minimale de l'interpréteur, fonctionnant uniquement pour des faits
+    \item Ajout du support des variables, toujours uniquement sur des faits
+    \item Ajout du support des clauses composées et récursives
+\end{enumerate}
+Ces phases sont détaillées dans la section \ref{subsec:projectPhases}.
 \subsection{Structure du rapport}
+Le rapport est découpé selon les différentes phases du projet. Chaque phase contient une partie d'analyse des besoins puis décrit la réalisation de ladite phase.
+
+Ce rapport fait l'hypothèse que le lecteur est familier avec le langage de programmation logique Prolog ainsi qu'avec le language Java, pour se concentrer sur les explications de la réalisation de l'interpréteur. Toutefois un glossaire des termes techniques utilisés est disponible en fin de document (section \ref{sec:glossary}).
 \end{document}
\ No newline at end of file