MisterChaos69/MiniJavaCompiler
2
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

parser implement fields

Browse Source
This commit is contained in:
Marvin Schlegel 2024-05-03 17:47:59 +02:00
parent fa9cb761d5
commit af7162ea54
2 changed files with 52 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Test/TestParser.hs
View File

@ -12,10 +12,17 @@ testSingleEmptyClass = TestCase $
testTwoEmptyClasses = TestCase $ testTwoEmptyClasses = TestCase $
assertEqual "expect two empty classes" [Class "Class1" [] [], Class "Class2" [] []] $ assertEqual "expect two empty classes" [Class "Class1" [] [], Class "Class2" [] []] $
parse [CLASS,IDENTIFIER "Class1",LBRACKET,RBRACKET,CLASS,IDENTIFIER "Class2",LBRACKET,RBRACKET] parse [CLASS,IDENTIFIER "Class1",LBRACKET,RBRACKET,CLASS,IDENTIFIER "Class2",LBRACKET,RBRACKET]
testBooleanField = TestCase $
assertEqual "expect class with boolean field" [Class "WithBool" [] [VariableDeclaration "boolean" "value" Nothing]] $
parse [CLASS,IDENTIFIER "WithBool",LBRACKET,BOOLEAN,IDENTIFIER "value",SEMICOLON,RBRACKET]
testIntField = TestCase $
assertEqual "expect class with int field" [Class "WithInt" [] [VariableDeclaration "int" "value" Nothing]] $
parse [CLASS,IDENTIFIER "WithInt",LBRACKET,INT,IDENTIFIER "value",SEMICOLON,RBRACKET]
tests = TestList [ tests = TestList [
testSingleEmptyClass, testSingleEmptyClass,
testTwoEmptyClasses testTwoEmptyClasses,
testBooleanField,
testIntField
] ]

67
src/Parser/JavaParser.y
View File

@ -89,17 +89,25 @@ qualifiedname : name DOT IDENTIFIER { }
simplename : IDENTIFIER { } simplename : IDENTIFIER { }
classdeclaration : CLASS IDENTIFIER classbody { case $3 of (methods, attributes) -> Class $2 methods attributes } classdeclaration : CLASS IDENTIFIER classbody { case $3 of (methods, fields) -> Class $2 methods fields }
| modifiers CLASS IDENTIFIER classbody { case $4 of (methods, attributes) -> Class $3 methods attributes } -- | modifiers CLASS IDENTIFIER classbody { case $4 of (methods, fields) -> Class $3 methods fields }
classbody : LBRACKET RBRACKET { ([], []) } classbody : LBRACKET RBRACKET { ([], []) }
| LBRACKET classbodydeclarations RBRACKET { ([], []) } | LBRACKET classbodydeclarations RBRACKET { $2 }
modifiers : modifier { } modifiers : modifier { }
| modifiers modifier { } | modifiers modifier { }
classbodydeclarations : classbodydeclaration { } classbodydeclarations : classbodydeclaration {
| classbodydeclarations classbodydeclaration{ } case $1 of
MethodDecl method -> ([method], [])
FieldDecls fields -> ([], fields)
}
-- | classbodydeclarations classbodydeclaration {
-- case ($1, $2) of
-- ((methods, fields), MethodDecl method) -> ((methods ++ [method]), fields)
-- ((methods, fields), FieldDecl field) -> (methods, (fields ++ [field]))
-- }
modifier : PUBLIC { } modifier : PUBLIC { }
| PROTECTED { } | PROTECTED { }
@ -109,19 +117,19 @@ modifier : PUBLIC { }
classtype : classorinterfacetype{ } classtype : classorinterfacetype{ }
classbodydeclaration : classmemberdeclaration { } classbodydeclaration : classmemberdeclaration { $1 }
| constructordeclaration { } -- | constructordeclaration { FieldDecl $ VariableDeclaration "int" "a" Nothing } -- TODO
classorinterfacetype : name{ } classorinterfacetype : name{ }
classmemberdeclaration : fielddeclaration { } classmemberdeclaration : fielddeclaration { $1 }
| methoddeclaration { } -- | methoddeclaration { }
constructordeclaration : constructordeclarator constructorbody { } constructordeclaration : constructordeclarator constructorbody { }
| modifiers constructordeclarator constructorbody { } | modifiers constructordeclarator constructorbody { }
fielddeclaration : type variabledeclarators SEMICOLON { } fielddeclaration : type variabledeclarators SEMICOLON { FieldDecls $ map (convertDeclarator $1) $2 }
| modifiers type variabledeclarators SEMICOLON { } -- | modifiers type variabledeclarators SEMICOLON {}
methoddeclaration : methodheader methodbody { } methoddeclaration : methodheader methodbody { }
@ -141,11 +149,11 @@ methodheader : type methoddeclarator { }
| VOID methoddeclarator { } | VOID methoddeclarator { }
| modifiers VOID methoddeclarator { } | modifiers VOID methoddeclarator { }
type : primitivetype { } type : primitivetype { $1 }
| referencetype { } -- | referencetype { }
variabledeclarators : variabledeclarator { } variabledeclarators : variabledeclarator { [$1] }
| variabledeclarators COMMA variabledeclarator { } -- | variabledeclarators COMMA variabledeclarator { $1 ++ [$3] }
methodbody : block { } methodbody : block { }
| SEMICOLON { } | SEMICOLON { }
@ -165,14 +173,14 @@ classtypelist : classtype { }
methoddeclarator : IDENTIFIER LBRACE RBRACE { } methoddeclarator : IDENTIFIER LBRACE RBRACE { }
| IDENTIFIER LBRACE formalparameterlist RBRACE { } | IDENTIFIER LBRACE formalparameterlist RBRACE { }
primitivetype : BOOLEAN { } primitivetype : BOOLEAN { "boolean" }
| numerictype { } | numerictype { $1 }
referencetype : classorinterfacetype { } referencetype : classorinterfacetype { }
variabledeclarator : variabledeclaratorid { } variabledeclarator : variabledeclaratorid { Declarator $1 Nothing }
| variabledeclaratorid ASSIGN variableinitializer { } -- | variabledeclaratorid ASSIGN variableinitializer { Declarator $1 Nothing } -- TODO
blockstatement : localvariabledeclarationstatement { } blockstatement : localvariabledeclarationstatement { }
| statement { } | statement { }
@ -182,9 +190,9 @@ formalparameter : type variabledeclaratorid { }
argumentlist : expression { } argumentlist : expression { }
| argumentlist COMMA expression { } | argumentlist COMMA expression { }
numerictype : integraltype { } numerictype : integraltype { $1 }
variabledeclaratorid : IDENTIFIER { } variabledeclaratorid : IDENTIFIER { $1 }
variableinitializer : expression { } variableinitializer : expression { }
@ -198,8 +206,8 @@ statement : statementwithouttrailingsubstatement{ }
expression : assignmentexpression { } expression : assignmentexpression { }
integraltype : INT { } integraltype : INT { "int" }
| CHAR { } | CHAR { "char" }
localvariabledeclaration : type variabledeclarators { } localvariabledeclaration : type variabledeclarators { }
@ -352,7 +360,18 @@ multiplicativeexpression : unaryexpression { }
{ {
data MethodOrFieldDeclaration = MethodDecl MethodDeclaration
| FieldDecls [VariableDeclaration]
data Declarator = Declarator Identifier (Maybe Expression)
-- convertDeclaratorList :: [DataType] -> MethodOrFieldDeclaration
-- convertDeclaratorList = FieldDecls $ map
convertDeclarator :: DataType -> Declarator -> VariableDeclaration
convertDeclarator dataType (Declarator id assigment) = VariableDeclaration dataType id assigment
parseError :: [Token] -> a parseError :: [Token] -> a
parseError _ = error "Parse error" parseError msg = error ("Parse error: " ++ show msg)
} }