Commentaires en français, vingtpagisation

FinalExample.java

@@ -1,13 +1,13 @@
 //////////////// FIRST CLASS TABLE /////////////////
 class MinGetter extends Object {
     /*
-        Returns the lesser of the two input integers
+        Renvoie le plus petit des entiers donnés.
     */
     Int min(Int a, Int b){
         return a.lt(b).ite(a,b);
     }
     /*
-        Returns the minimum of the input list, None if the list is empty.
+        Renvoie le minimum de la liste, renvoie None si elle est vide.
     */
     Optional listMin(List a) {
         return a.ensureFinite().isEmpty().ite(new None(), new Some(this.min((Int)this.listMin(a.tail).orElse(a.head), a.head)))
@@ -18,7 +18,7 @@ class Sort extends Object {
         ensure(in).isEmpty().ite(in,minOnStart(in,(Int)((Some)new MinGetter().listMin(in)).value));
     }
     /*
-        Put the first occurence of 'min' in 'in' to the start of the list and sort the rest.
+        Place la première occurence de 'min' trouvée dans 'in' au début de la liste, et trie le reste.
     */
     List minOnStart(List in, Int min) {
         return min::this.sort(in.removeFirst(min));
@@ -28,13 +28,13 @@ class Sort extends Object {
 ///////////////// SECOND CLASS TABLE /////////////////
 class MaxGetter extends Object {
     /*
-        Returns the bigger of the two input integers
+        Renvoie le plus grand des entiers donnés.
     */
     Int max(Int a, Int b){
         return a.gt(b).ite(a,b);
     }
     /*
-        Returns the maximum of the input list, None if the list is empty
+        Renvoie le maximum de la liste, renvoie None si elle est vide.
     */
     Optional listMax(List a) {
         return a.ensureFinite().isEmpty().ite(
@@ -54,7 +54,7 @@ class Sort extends Object {
     }
     
     /*
-        Removes max from in, applies sortAcc on the new list, and adds max to the accumulator.
+        Enlève 'max' de la liste 'in', et applique sortAcc en ajoutant max à l'accumulateur.
     */
     List maxToEnd(List in, Int max) {
         return this.sortAcc(in.removeFirst(max), max::in.removeFirst(max));
@@ -62,17 +62,17 @@ class Sort extends Object {
 }
 
 ///////////////// TEST INTERFACE /////////////////¨
-// These three lines gives access to Integer construction
+// Ces trois lignes permettent de construire les entiers
 Int ()
 S (Int)
 S <: Int
 
-// These three lines allows line construction
+// Ces trois lines permettent de construire les listes
 List ()
 Cons (List, o)
 Cons <: List
 
-// These two lines allows use of the sort function,
-// the only one whose implementation differs between the two class tables.
+// Ces deux lignes permettent l'utilisation des méthodes de tri
+// C'est le seul endroit où les deux class tables diffèrent du point de vue de la test interface.
 Sort ()
 Sort: sort(List)

RapportStage.tex

@@ -226,8 +226,9 @@
 		
 		Tous les tests présentés dans la section précédente visaient à tester un programme entier (une \eng{class table} et une expression). Il semble cependant étrange de procéder ainsi. En effet, un développeur souhaitera principalement comparer entre elles des librairies, ce qui correspondrait à nos \eng{class tables}. On ne cherche plus à savoir si deux programmes \enquote{font la même chose}, mais plutôt est-ce que ces deux \eng{class tables} fournissent les mêmes fonctions.
 		
-		En bonus, l'étude des \eng{class tables} est tout aussi complète que l'étude des programmes entiers, car nous pouvons toujours rajouter une classe \fj{Main} qui n'aie qu'une méthode \fj{Main.main} dont le corps soit l'expression de notre programme. Alors tester cette nouvelle \eng{class table} reviendra à tester le programme entier.
+		En bonus, l'étude des \eng{class tables} est tout aussi complète que l'étude des programmes entiers, car nous pouvons toujours rajouter une classe \fj{Main} qui n'aie qu'une méthode \fj{Main.main} dont le corps soit l'expression de notre programme. Alors tester cette nouvelle \eng{class table} reviendra à tester le programme entier. La transformation est présentée \autoref{fig:prgToCT}.
 		
+		\begin{figure}
 		\begin{center}
 		\begin{multicols}{2}
 		\null\vfill
@@ -239,7 +240,6 @@
 		\end{fjlisting}
 		\vfill\null
 		\columnbreak
-		\null\vfill
 		\begin{fjlisting}[width=.4\textwidth]
 			class XXX extends XXX \{\\
 			\}\\
@@ -248,9 +248,11 @@
 				\fjmethod{Object}{main}{}{expression}
 			}
 		\end{fjlisting}
-		\vfill\null
 		\end{multicols}
 		\end{center}
+		\caption{Transformation d'un programme en \eng{class table}}
+		\label{fig:prgToCT}
+		\end{figure}
 		Alors, on a transformé le \emph{programme} en \emph{\eng{class table}}, et si nous voulons tester le main du programme, il suffit de tester ce que renvoie l'expression \fj{new Main().main()}, qui se réduit en une étape en le main du programme.
 		
 		\paragraph{Idée d'une nouvelle structure}
@@ -566,7 +568,7 @@
 			
 			Nous noterons la plupart du temps simplement $\prec$ pour désigner $\prec_\mathfrak{T}$ si la \eng{test interface} considérée est sans ambiguïté.
 			
-			Nous allons d'abord renforcer ce préordre, avant de fournir un exemple complet \autoref{sec:exPreordre}.
+			Nous allons déjà renforcer ce préordre, avant de fournir un exemple complet \autoref{sec:exPreordre}.
 																						
 		\subsection{Renforcement de ce préordre avec les valeurs infinies}
 		
@@ -671,7 +673,7 @@
 				\begin{figure}
 					\begin{tcolorbox}
 						\small
-						\lstinputlisting[language=FeatherweightJava,breaklines=true,linerange={29-62}]{FinalExample.java}
+						\lstinputlisting[language=FeatherweightJava,breaklines=true,linerange={29-62}, texcl]{FinalExample.java}
 					\end{tcolorbox}
 					\caption{Seconde \eng{class tables}}
 					\label{fig:equivex:second}

header.tex

@@ -150,7 +150,12 @@
 \lstdefinelanguage{FeatherweightJava}{
 	keywords = {new, this, true, false},
 	basicstyle=\ttfamily,
-	identifierstyle=\idstyle
+	identifierstyle=\idstyle,
+	literate=%
+		{à}{{\`a}}1
+		{é}{{\'e}}1
+		{è}{{\`e}}1
+		{ù}{{\`u}}1
 }
 
 %% Commande 4