diff --git a/Test/JavaSources/Main.java b/Test/JavaSources/Main.java index acf0eed..02bfcc2 100644 --- a/Test/JavaSources/Main.java +++ b/Test/JavaSources/Main.java @@ -17,6 +17,8 @@ public class Main { TestMalicious malicious = new TestMalicious(); TestLoop loop = new TestLoop(); TestMethodOverload overload = new TestMethodOverload(); + TestShenanigance shenanigance = new TestShenanigance(); + TestOptionalParameter optionalParameter = new TestOptionalParameter(); // constructing a basic class works assert empty != null; @@ -35,6 +37,7 @@ public class Main { // self-referencing methods work. assert recursion.fibonacci(15) == 610; assert loop.factorial(5) == 120; + assert loop.weirdFor() == 5; // methods with the same name but different parameters work assert overload.MethodOverload() == 42; assert overload.MethodOverload(15) == 42 + 15; @@ -48,5 +51,14 @@ public class Main { { assert malicious.cursedFormatting(i) == i; } + // other syntactic sugar + assert shenanigance.testAssignment() == 5; + assert shenanigance.divEqual() == 234_343_000 / 4; + assert shenanigance.testIf(5); + // optional parameters + assert optionalParameter.oneOptional() == 1; + assert optionalParameter.oneOptional(2) == 2; + assert optionalParameter.normalAndOptional(1) == 6; + assert optionalParameter.normalAndOptional(1, 0) == 4; } } diff --git a/Test/JavaSources/TestLoop.java b/Test/JavaSources/TestLoop.java index 40491fb..1976c48 100644 --- a/Test/JavaSources/TestLoop.java +++ b/Test/JavaSources/TestLoop.java @@ -9,4 +9,11 @@ public class TestLoop { return tally; } + + int weirdFor() { + int k = 0; + for (; k < 5; k++) { + } + return k; + } } diff --git a/Test/JavaSources/TestOptionalParameter.java b/Test/JavaSources/TestOptionalParameter.java new file mode 100644 index 0000000..faba782 --- /dev/null +++ b/Test/JavaSources/TestOptionalParameter.java @@ -0,0 +1,10 @@ +class TestOptionalParameter { + + int oneOptional(int p = 1) { + return p; + } + + int normalAndOptional(int a, int b = 2, int c = 3) { + return a + b + c; + } +} \ No newline at end of file diff --git a/Test/JavaSources/TestShenanigance.java b/Test/JavaSources/TestShenanigance.java new file mode 100644 index 0000000..693d73e --- /dev/null +++ b/Test/JavaSources/TestShenanigance.java @@ -0,0 +1,25 @@ +class TestShenanigance { + + int testAssignment() { + int x = 1; + int y = x = 5; + return y; + } + + int divEqual() { + int x = 234_343_000; + x /= 4; + return x; + } + + boolean testIf(int x) { + if (true && x < 8) { + char f = 'c'; + return f > x ; + } + ifn't { + return false; + } + } + +} \ No newline at end of file diff --git a/doc/documentation.pdf b/doc/documentation.pdf index 13b81ef..c983225 100644 Binary files a/doc/documentation.pdf and b/doc/documentation.pdf differ diff --git a/doc/parser.tex b/doc/parser.tex index 877e46a..ba17eb2 100644 --- a/doc/parser.tex +++ b/doc/parser.tex @@ -1,35 +1,65 @@ \section{Lexer \& Parser} \subsection{Lexer} -Der Lexer wurde mit dem Alex tool implementiert. Dieser ist dafür zuständig den langen String in einzelne Tokens umzuwandeln. -In der Alex Datei gibt es für jedes Token einen regulären Ausdruck. Bei den meisten Tokens ist das einfach das Schlüsselwort. -Etwas komplexer waren Identifier, Integerliterale Strings und Chars. -Für die Definition wurde sich eng an die offizielle Java Language Specification gehalten. -Es ist beispielsweise auch möglich Unterstriche in Integerliterale einzubauen (Bsp.: \texttt{234\_343\_000}). -Es sind fast alle Schlüsselwörter von Java im Lexer implementiert, auch wenn nicht alle davon vom Parser geparst werden können. -Whitespace und Kommentare werden direkt ignoriert und verworfen. -Für Charliterale und Integerliterale gibt es auch spezielle Fehlermeldungen. Die meisten Tokens haben nur die Information, zu welchem Keyword sie gehören. -Eine Ausnahme bilden der Identifier und die Literale. Für den Identifier wird noch der Name gespeichert und für die Literale der entsprechende Wert. -Mit der Funktion alexScanTokens kann dann ein beliebiger String in Tokens umgewandelt werden. -Die komplexeren Tokens haben Unittests, welche mit dem Testframework HUnit geschrieben wurden. -Es gibt Tests für Kommentare, Identifier, Literale und ein paar weitere Tokens. +Der Lexer wurde mit dem Alex tool implementiert. Dieser ist dafür zuständig den langen String in einzelne Tokens umzuwandeln. In der Alex Datei gibt es für jedes Token einen regulären Ausdruck. Bei den meisten Tokens ist das einfach das Schlüsselwort. Etwas komplexer waren Identifier, Integerliterale Strings und Chars. Für die Definition wurde sich eng an die offizielle Java Language Specification gehalten. Es ist beispielsweise auch möglich Unterstriche in Integerliterale einzubauen (Bsp.: \verb|234_343_000|) Es sind fast alle Schlüsselwörter von Java im Lexer implementiert, auch wenn nicht alle davon vom Parser geparst werden können. Whitespace und Kommentare werden direkt ignoriert und verworfen. Für Charliterale und Integerliterale gibt es auch spezielle Fehlermeldungen. Die meisten Tokens haben nur die Information, zu welchem Keyword sie gehören. Eine Ausnahme bilden der Identifier und die Literale. Für den Identifier wird noch der Name gespeichert und für die Literale der entsprechende Wert. Mit der Funktion alexScanTokens kann dann ein beliebiger String in Tokens umgewandelt werden. + +Die komplexeren Tokens haben Unittests, welche mit dem Testframework HUnit geschrieben wurden. Es gibt Tests für Kommentare, Identifier, Literale und ein paar weitere Tokens. \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. -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. Als erstes wurden leere Methoden und Felder umgesetzt. -Da in Java Methoden und Felder durcheinander vorkommen können geben die Ableitungsregeln einen Datentype namens \texttt{MethodOrFieldDeclaration} zurück. -Über Pattern Matching baut die classbodydeclarations Regel dann eine Tupel mit einer Liste aus Methoden und einer aus Feldern. -Über pattern matching werden diese Listen dann erweitert und in der darüberliegenden Regel schließlich extrahiert. -Die Konstruktoren sind in diesem Fall auch normale Methoden mit dem Rückgabewert `void` und dem Namen \texttt{}. -Auf diese Weise müssen sie nicht mehr vom Typcheck oder vom Bytecode verändert werden. -In Java ist es möglich mehrere Variablen in einer Zeile zu deklarieren (Bsp.: \texttt{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. -Für die Zuweisung wird auch die Kombination mit Rechenoperatoren unterstützt. Das Ganze ist als syntactic sugar im Parser umgesetzt. -Wenn es einen Zuweisungsoperator gibt, dann wird der Ausdruck in eine Zuweisung und Rechnung aufgeteilt. -Bsp.: \texttt{x += 3;} wird umgewandelt zu \texttt{x = x + 3}. +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. + +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. + +\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. + +Bei folgender Klasse: +\begin{lstlisting}[language=Java] +class TestClass { + int field; + + TestClass() {} + + void foo() {} +} +\end{lstlisting} +würde die Regel folgendes Tupel zurückgeben: +\begin{lstlisting}[language=Haskell] +( + [ConstructorDeclaration "TestClass" [] (Block [])], + [MethodDeclaration "void" "foo" [] (Block [])], + [VariableDeclaration "int" "field" Nothing] +) +\end{lstlisting} +und folgende Klasse wird erstellt +\begin{lstlisting}[language=Haskell] +Class "TestClass" + [ConstructorDeclaration "TestClass" [] (Block [])] + [MethodDeclaration "void" "foo" [] (Block [])] + [VariableDeclaration "int" "field" Nothing] +\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} +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. + +\begin{lstlisting}[language=Java] +for (int i = 0; i < 9; i++) { + foo(); +} +\end{lstlisting} +wird umgewandelt in: +\begin{lstlisting}[language=Java] +{ + int i = 0; + while (i < 9) { + foo(); + i++; + } +} +\end{lstlisting} diff --git a/src/Parser/JavaParser.y b/src/Parser/JavaParser.y index fe8bf0c..841d68c 100644 --- a/src/Parser/JavaParser.y +++ b/src/Parser/JavaParser.y @@ -1,5 +1,5 @@ { -module Parser.JavaParser (parse, parseStatement, parseExpression) where +module Parser.JavaParser (parse, parseStatement, parseExpression, parseMethod) where import Ast import Parser.Lexer } @@ -7,6 +7,7 @@ import Parser.Lexer %name parse %name parseStatement statement %name parseExpression expression +%name parseMethod classbodydeclarations %tokentype { Token } %error { parseError } %errorhandlertype explist @@ -104,13 +105,13 @@ modifiers : modifier { } classbodydeclarations : classbodydeclaration { case $1 of ConstructorDecl constructor -> ([constructor], [], []) - MethodDecl method -> ([], [method], []) + MethodDecl method -> ([], (convertMethodDeclarationWithOptionals method), []) FieldDecls fields -> ([], [], fields) } | classbodydeclarations classbodydeclaration { case ($1, $2) of ((constructors, methods, fields), ConstructorDecl constructor) -> ((constructors ++ [constructor]), methods, fields) - ((constructors, methods, fields), MethodDecl method) -> (constructors, (methods ++ [method]), fields) + ((constructors, methods, fields), MethodDecl method) -> (constructors, (methods ++ (convertMethodDeclarationWithOptionals method)), fields) ((constructors, methods, fields), FieldDecls newFields) -> (constructors, methods, (fields ++ newFields)) } @@ -136,7 +137,7 @@ constructordeclaration : constructordeclarator constructorbody { case $1 of (ide fielddeclaration : type variabledeclarators SEMICOLON { FieldDecls $ map (convertDeclarator $1) $2 } | modifiers type variabledeclarators SEMICOLON { FieldDecls $ map (convertDeclarator $2) $3 } -methoddeclaration : methodheader methodbody { case $1 of (returnType, (name, parameters)) -> MethodDecl (MethodDeclaration returnType name parameters $2) } +methoddeclaration : methodheader methodbody { case $1 of (returnType, (name, (parameters, optionalparameters))) -> MethodDecl (MethodDeclarationWithOptionals returnType name parameters optionalparameters $2) } block : LBRACKET RBRACKET { Block [] } | LBRACKET blockstatements RBRACKET { Block $2 } @@ -166,6 +167,10 @@ methodbody : block { $1 } blockstatements : blockstatement { $1 } | blockstatements blockstatement { $1 ++ $2} +formalandoptionalparameterlist : formalparameterlist { ($1, []) } + | formalparameterlist COMMA optionalparameterlist { ($1, $3) } + | optionalparameterlist { ([], $1) } + formalparameterlist : formalparameter { [$1] } | formalparameterlist COMMA formalparameter { $1 ++ [$3] } @@ -175,8 +180,13 @@ explicitconstructorinvocation : THIS LBRACE RBRACE SEMICOLON { } classtypelist : classtype { } | classtypelist COMMA classtype { } -methoddeclarator : IDENTIFIER LBRACE RBRACE { ($1, []) } - | IDENTIFIER LBRACE formalparameterlist RBRACE { ($1, $3) } +methoddeclarator : IDENTIFIER LBRACE RBRACE { ($1, ([], [])) } + | IDENTIFIER LBRACE formalandoptionalparameterlist RBRACE { ($1, $3) } + +optionalparameterlist : optionalparameter { [$1] } + | optionalparameterlist COMMA optionalparameter { $1 ++ [$3] } + +optionalparameter : type variabledeclaratorid ASSIGN variableinitializer { OptionalParameter $1 $2 $4 } primitivetype : BOOLEAN { "boolean" } | numerictype { $1 } @@ -386,9 +396,9 @@ multiplicativeexpression : unaryexpression { $1 } { -data MethodOrFieldDeclaration = MethodDecl MethodDeclaration +data MemberDeclaration = MethodDecl MethodDeclarationWithOptionals | ConstructorDecl ConstructorDeclaration - | FieldDecls [VariableDeclaration] + | FieldDecls [VariableDeclaration] deriving (Show) data Declarator = Declarator Identifier (Maybe Expression) @@ -399,6 +409,22 @@ extractFunctionName :: Expression -> (Expression, Identifier) extractFunctionName (BinaryOperation NameResolution exp (Reference functionname)) = (exp, functionname) extractFunctionName (Reference functionname) = ((Reference "this"), functionname) +data OptionalParameter = OptionalParameter DataType Identifier Expression deriving (Show) +data MethodDeclarationWithOptionals = MethodDeclarationWithOptionals DataType Identifier [ParameterDeclaration] [OptionalParameter] Statement deriving (Show) +convertMethodDeclarationWithOptionals :: MethodDeclarationWithOptionals -> [MethodDeclaration] +convertMethodDeclarationWithOptionals (MethodDeclarationWithOptionals returnType id param [] stmt) = [MethodDeclaration returnType id param stmt] +convertMethodDeclarationWithOptionals (MethodDeclarationWithOptionals returnType id param (opt : optRest) stmt) = generateHelperMethod returnType id param opt : convertMethodDeclarationWithOptionals (generateBaseMethod returnType id param opt optRest stmt) +convertOptionalParameter :: OptionalParameter -> ParameterDeclaration +convertOptionalParameter (OptionalParameter dtype id exp) = ParameterDeclaration dtype id +generateHelperMethod :: DataType -> Identifier -> [ParameterDeclaration] -> OptionalParameter -> MethodDeclaration +generateHelperMethod returnType methodName params (OptionalParameter dtype id exp) = + let references = ((map (\(ParameterDeclaration paramType ident) -> (Reference ident)) params) ++ [exp]) + methodcall = (MethodCall (Reference "this") methodName references) + lastStatement = if returnType == "void" then StatementExpressionStatement methodcall else Return $ Just $ StatementExpressionExpression methodcall + in MethodDeclaration returnType methodName params $ Block [lastStatement] +generateBaseMethod :: DataType -> Identifier -> [ParameterDeclaration] -> OptionalParameter -> [OptionalParameter] -> Statement -> MethodDeclarationWithOptionals +generateBaseMethod returnType methodName params (OptionalParameter dtype id exp) optRest stmt = MethodDeclarationWithOptionals returnType methodName (params ++ [ParameterDeclaration dtype id]) optRest stmt + parseError :: ([Token], [String]) -> a parseError (errortoken, expected) = error ("parse error on token: " ++ show errortoken ++ "\nexpected one of: " ++ show expected)