Parser and type checker almost completely working

Added testing env

src/Parser/Enum.hs

@@ -7,16 +7,14 @@ import Text.Megaparsec.Char
 import Text.Megaparsec
 import Model.Enum
 
---parseTest enumParser "enum periodEnum: <\"description\"> D displayName \"day\" <\"Day\">"
 enumParser :: Parser EnumType
 enumParser = 
     do 
         eName <- enumNameParser
         eDescription <- optional descriptionParser
-        values <- many enumValueParser
+        values <- some enumValueParser
         return (MakeEnum eName eDescription values)
-
---parseTest enumValueParser "D displayName \"day\" <\"Day\">"        
+    
 enumValueParser :: Parser EnumValue
 enumValueParser = 
     do
@@ -38,24 +36,4 @@ enumNameParser =
         _ <- lexeme $ string "enum"
         name <- nameParser
         _ <- lexeme $ char ':'
-        return name 
-
-periodEnum :: EnumType
-periodEnum = MakeEnum 
-    "PeriodEnum" 
-    (Just "The enumerated values to specifie the period, e.g. day, week.")
-    [MakeEnumValue 
-    "D"
-    (Just "Day")
-    Nothing,
-    
-    MakeEnumValue
-    "W"
-    (Just "Week")
-    Nothing,
-    
-    MakeEnumValue
-    "Y"
-    (Just "Year")
-    Nothing
-    ]
+        return name 

src/Parser/Expression.hs

@@ -75,7 +75,7 @@ integerParser :: Parser Expression
 integerParser =
     do
         nr <- lexeme $ some digitChar
-        return $ Int $ show nr
+        return $ Int nr
         
 decimalParser :: Parser Expression
 decimalParser =
@@ -83,7 +83,7 @@ decimalParser =
         nr <- some digitChar
         _ <- char '.'
         real <- lexeme $ many digitChar
-        return $ Real $ show nr ++ "." ++ real
+        return $ Real $ nr ++ "." ++ real
         
 booleanParser :: Parser Expression
 booleanParser =
@@ -202,18 +202,4 @@ precedence "^" = 4
 precedence _ = 100
 
 prefixOperators :: [String]
-prefixOperators = ["-", "not"]
-
-testArith3 = parseTest expressionParser "1 + (2 - 3)"
-testArith4 = parseTest expressionParser "a * b - c * d - e * f = g * h - i * j - k * l"
-testArith5 = parseTest expressionParser "a + b - c * d ^ e"
-testArith6 = parseTest expressionParser "1 - 2 - 3 - 4 - 5 - 6"
-testList = parseTest expressionParser "[1, 2, 3]"
-testList2 = parseTest expressionParser "[1, 2 + 3, e]"
-testFun = parseTest functionCallParser "Function()"
-testFun2 = parseTest functionCallParser "Function(e)"
-testFun3 = parseTest functionCallParser "Function(3, 3+2,e)"
-testIf = parseTest expressionParser "if (Function(2 + 3, e)) then a + b - c * d ^ e -> x else not a exists"
-testEverything = parseTest expressionParser "if [1, Function(3)] then 1 - 2 - 3 * a -> b ^ c"
-testFail = parseTest expressionParser "if[1,as]thenxandoelseaora"
-testOr = parseTest expressionParser "a or b"
+prefixOperators = ["-", "not"]

src/Parser/Type.hs

@@ -7,7 +7,6 @@ import Text.Megaparsec.Char
 import Text.Megaparsec
 import Parser.General 
   
---parseTest typeParser "type Period: <\"description\"> periodMultiplier int (1..1) <\"A time period multiplier\"> period periodEnum (1..1) <\"A time period \">"
 typeParser :: Parser Type
 typeParser = 
     do 
@@ -21,7 +20,7 @@ typeParser =
 superTypeParser :: Parser Type
 superTypeParser =
     do
-        _ <- lexeme $ string "extending"
+        _ <- lexeme $ string "extends"
         name <- pascalNameParser 
         return $ MakeType name Nothing Nothing []
 
@@ -37,55 +36,36 @@ typeAttributeParser =
 cardinalityParser :: Parser Cardinality
 cardinalityParser =
     do
-        parseExactlyOne <|> parseOneOrMore <|> parseZeroOrMore <|> parseZeroOrOne
+        try parseBounded <|> try parseSemiBounded <|> try parseUnbounded
 
-parseOneOrMore :: Parser Cardinality
-parseOneOrMore = 
+parseBounded :: Parser Cardinality
+parseBounded = 
     do
-        _ <- lexeme $ string "(1..*)"
-        return OneOrMore
+        _ <- lexeme $ char '('
+        low <- lexeme $ many digitChar
+        _ <- lexeme $ string ".."
+        up <- lexeme $ many digitChar
+        _ <- lexeme $ char ')'
+        return $ Bounds (read low, read up)
 
 
-parseExactlyOne :: Parser Cardinality
-parseExactlyOne = 
+parseSemiBounded :: Parser Cardinality
+parseSemiBounded = 
     do
-        _ <- lexeme $ string "(1..1)"
-        return ExactlyOne
+        _ <- lexeme $ char '('
+        low <- lexeme $ many digitChar
+        _ <- lexeme $ string "..*)"
+        return $ OneBound $ read low
         
         
-parseZeroOrMore :: Parser Cardinality
-parseZeroOrMore = 
+parseUnbounded :: Parser Cardinality
+parseUnbounded = 
     do
-        _ <- lexeme $ string "(0..*)"
-        return ZeroOrMore
-        
-        
-parseZeroOrOne :: Parser Cardinality
-parseZeroOrOne = 
-    do
-        _ <- lexeme $ string "(0..1)"
-        return ZeroOrOne
+        _ <- lexeme $ string "(*..*)"
+        return NoBounds
 
 typeNameParser :: Parser String
 typeNameParser = 
     do
         _ <- lexeme $ string "type"
-        pascalNameParser
-        
-periodType :: Type
-periodType = MakeType 
-    "Period" 
-    Nothing
-    (Just "A class to define recurring periods or time offsets")
-    [MakeTypeAttribute 
-        "periodMultiplier"
-        (BasicType "Integer")
-        ExactlyOne
-        (Just "A time period multiplier"),
-    
-    MakeTypeAttribute 
-        "period"
-        (MakeType "PeriodEnum" Nothing Nothing [])
-        ExactlyOne
-        (Just "A time period")
-    ]
+        pascalNameParser