doc/documentation.tex

@@ -16,6 +16,39 @@
     filecolor=magenta,      
     urlcolor=cyan,
 }
+
+%for code listings
+\usepackage{listings}
+\usepackage{xcolor}
+\definecolor{ListingBackground}{HTML}{F8F8F8}
+\lstdefinestyle{mystyle}{
+		language=Java,			% default language
+		numbers=left,			% position of line numbers (left, right)
+		stepnumber=1,			% set number to each line
+		numbersep=5pt,			% 5pt between number and source code
+		numberstyle=\tiny,			% letter size of numbers
+		breaklines=true,		       	 % break lines if necessary (true, false)
+		breakautoindent=true,	        	% indenting after break line (true, false)
+		postbreak=\space,			% break line after space
+		tabsize=2,				% tabulator size
+		basicstyle=\ttfamily\footnotesize, % font style
+		showspaces=false,			% show space (true, false)
+		extendedchars=true,		% show all Latin1 characters (true, false)
+		captionpos=b,			% sets the caption-position to bottom
+		backgroundcolor=\color{ListingBackground}, % source code background
+		xleftmargin=10pt,		        % margin left
+		xrightmargin=5pt,		        % margin right
+		frame=single,			% border settings
+		frameround=ffff,
+		rulecolor=\color{darkgray},	% border color
+		fillcolor=\color{ListingBackground},
+		aboveskip=20pt,
+		keywordstyle=\color[rgb]{0.133,0.133,0.6},
+		commentstyle=\color[rgb]{0.133,0.545,0.133},
+		stringstyle=\color[rgb]{0.627,0.126,0.941}
+}
+\lstset{style=mystyle}
+
 \let\clearpage\relax
 
 \begin{document}

doc/features.tex

@@ -15,7 +15,7 @@
     \item Binar-Operationen (\texttt{\&, |, \^})
     \item Pre/Post-Inkrement \& Dekrement
     \item Kontrollflussstrukturen:
-    \begin{itemize}
+    \begin{itemize}[noitemsep]
         \item If/Else
         \item While
         \item For
@@ -31,4 +31,5 @@
     \item Deklaration und Zuweisung in einer Anweisung
     \item Beliebig verschachtelte Blöcke
     \item Überladung von Methoden \& Konstruktoren
+    \item Parameter mit Standardwerten
 \end{itemize}

doc/parser.tex

@@ -7,13 +7,14 @@ Die komplexeren Tokens haben Unittests, welche mit dem Testframework HUnit gesch
 
 \subsection{Parser}
 
-Der Parser wurde mit dem Happy tool implementiert. Er baut aus einer Liste von Tokens einen ungetypten AST. Wir haben bereits eine Grammatik bekommen und mussten diese noch in den AST umwandeln.
+Der Parser wurde mit dem Happy tool implementiert. Er baut aus einer Liste von Tokens einen ungetypten AST. Wir haben bereits eine Grammatik bekommen und mussten für die einzelnen Regeln noch die Rückgabewerte angeben.
 
-Um den Parser aufzubauen wurde zuerst ein Großteil der Grammatik auskommentiert und Stück für Stück wurden die Umwandlungen hinzugefügt. Immer wenn ein neues Feature umgesetzt wurde, wurde dafür ein weiterer Unit Test geschrieben. Es gibt also für jede komplexe Ableitungsregel mindestens einen Unittest.
+Um den Parser aufzubauen wurde zuerst ein Großteil der Grammatik auskommentiert und Stück für Stück wurden die Rückgabewerte hinzugefügt. Immer wenn ein neues Feature umgesetzt wurde, wurde dafür ein weiterer Unit Test geschrieben. Es gibt also für jede komplexe Ableitungsregel mindestens einen Unittest.
 
 \subsubsection{Klassenaufbau}
-Als erstes wurden leere Konstruktoren Methoden und Felder umgesetzt. Da in Java Konstruktoren, Methoden und Felder durcheinander vorkommen können geben die Ableitungsregeln einen Datentyp namens `MemberDeclaration` zurück. Die classbodydeclarations Regel baut dann einen 3-Tupel mit einer Liste aus Konstruktoren, einer aus Methoden und einer aus Feldern. Über pattern matching werden diese Listen dann erweitert und in der darüberliegenden Regel schließlich extrahiert.
+Als erstes wurden leere Konstruktoren Methoden und Felder umgesetzt. Da in Java Konstruktoren, Methoden und Felder durcheinander vorkommen können geben die Ableitungsregeln einen Datentyp namens MemberDeclaration zurück, welcher eines von den drei enthalten kann. Die \verb|classbodydeclarations| Regel baut dann einen 3-Tupel mit einer Liste aus Konstruktoren, einer aus Methoden und einer aus Feldern. Über Pattern Matching werden diese Listen dann erweitert und in der darüberliegenden Regel schließlich extrahiert.
 
+\pagebreak
 Bei folgender Klasse:
 \begin{lstlisting}[language=Java]
 class TestClass {
@@ -41,12 +42,13 @@ Class "TestClass"
 \end{lstlisting}
 Das Nothing ist in diesem Fall ein Platzhalter für eine Zuweisung, da unser Compiler auch Zuweisung bei der Felddeklaration unterstützt.
 
-In Java ist es möglich mehrere Variablen in einer Zeile zu deklarieren (Bsp.: `int x, y;`). Beim Parsen ergiebt sich dann die Schwierigkeit, dass man in dem Moment, wo man die Variable parst nicht weiß welchen Datentyp diese hat. Aus diesem Grund gibt es den Datentyp Declarator, welcher nur den Identifier und eventuell eine Zuweisung enthält. In den darüberliegenden Regeln fielddeclaration und localvariabledeclaration wird dann die Typinformation hinzugefügt mithilfe der Funktion convertDeclarator.
-
 \subsubsection{Syntactic Sugar}
+
+In Java ist es möglich mehrere Variablen in einer Zeile zu deklarieren (Bsp.: \verb|int x, y;|). Beim Parsen ergibt sich dann die Schwierigkeit, dass man in dem Moment, in dem man die Variable parst, nicht weiß welchen Datentyp diese hat. Aus diesem Grund gibt es den Datentyp Declarator, welcher nur den Identifier und eventuell eine Zuweisung enthält. In den darüberliegenden Regeln \verb|fielddeclaration| und \verb|localvariabledeclaration| wird dann die Typinformation hinzugefügt mithilfe der Funktion \verb|convertDeclarator|.
+
 Für die Zuweisung wird auch die Kombination mit Rechenoperatoren unterstützt. Das ganze ist durch Syntactic Sugar im Parser umgesetzt. Wenn es einen Zuweisungsoperator gibt, dann wird der Ausdruck in eine Zuweisung und Rechnung aufgeteilt. Bsp.: \verb|x += 3;| wird umgewandelt in \verb|x = x + 3|.
 
-For-Schleifen wurde auch rein im Parser durch Syntactic Sugar implementiert. Eine For-Schleife wird dabei in eine While-Schleife umgewandelt. Dafür wird zuerst ein Block erstellt, sodass die deklarierten Variablen auch nur für den Bereich der Schleife gültig sind. Die Bedingung der For-Schleife kann in die While-Schleife übernommen werden. Innerhalb der While-Schleife folgen zuerst die Statements, die im Block der For-Schleife waren und danach die Update-Statements.
+For-Schleifen wurden auch rein im Parser durch Syntactic Sugar implementiert. Eine For-Schleife wird dabei in eine While-Schleife umgewandelt. Dafür wird zuerst ein Block erstellt, sodass die deklarierten Variablen auch nur für den Bereich der Schleife gültig sind. Die Bedingung der For-Schleife kann in die While-Schleife übernommen werden. Innerhalb der While-Schleife folgen zuerst die Statements, die im Block der For-Schleife waren und danach die Update-Statements.
 
 \begin{lstlisting}[language=Java]
 for (int i = 0; i < 9; i++) {
@@ -63,3 +65,24 @@ wird umgewandelt in:
     }
 }
 \end{lstlisting}
+
+Es wurden auch Parameter mit Standardwerten im Parser implementiert. Dieses Feature ist in der aktuellen Java Version (Java 22) noch nicht implementiert. Der Parser macht sich dafür das Überladen von Methoden zunutze. Er generiert für jedes Parameter mit Standardwert eine weitere Funktion, welche die ursprüngliche Funktion mit einem Standardwert aufruft.
+
+%\lstinputlisting[language=Java,firstline=7,lastline=9]{../Test/JavaSources/TestOptionalParameter.java}
+\begin{lstlisting}[language=Java]
+int normalAndOptional(int a, int b = 2, int c = 3) {
+    return a + b + c;
+}
+\end{lstlisting}
+wird umgewandelt in:
+\begin{lstlisting}
+int normalAndOptional(int a) {
+    return normalAndOptional(a, 2);
+}
+int normalAndOptional(int a, int b) {
+    return normalAndOptional(a, b, 3);
+}
+int normalAndOptional(int a, int b, int c) {
+    return a + b + c;
+}
+\end{lstlisting}