####### DOCUMENTATIATOIAITAT ION ########
-a simple c-like language with support for if/else-statements, while-loops and the standard arithmetic (+, -, /, *) and comparison expressions (<, >, <=, >=, ==, !=). also, post increase/decrease expressions (++, --) are supported.
+Files:
+Typechecker.hs: Simple modification of the bnfc-generated Testsyntax which calls the type-checking functions.
-data types:
-integers and booleans.
+Typecheck.hs: Contains the type-checking functions typeCheckExp, typeCheckVar and typeCheckStm and some utility functions, responsible for the entire type-checking process.
-comments:
-// and /* */ comments are allowed.
+Abssyntax.hs, Parsyntax.y, Lexsyntax.x,ErrM.hs,Printsyntax.hs,Skelsyntax.hs: The files generated by bnfc, only modification is the removal of the Bool type in Abssyntx.hs so haskell's internal type can be used.
-(For compilation to work the Bool type in Abssyntax has to be removed so the internal haskell type is used)
-shift/reduce conflicts:
+typing rules
+++++++++++++
-18 conflicts in total.
-1) Exp1 followed by (<,<=,>,>=,==,!=,+,-) 8 conflicts:
-In these cases the Exp1 could've been reduced to Exp, but happy does the correct thing and shifts the operator token onto the stack, since Exp followed by these operators doesn't match any rules.
+(t is used for types, T is the context, and + is used for in)
-2) Exp2 followed by (*,/) 4 conflicts:
-In two cases the Exp2 expression could be reduced to Exp1, but this wouldn't match the rules for these operators, so shifting is the correct action.
-In two other cases the Exp2 in front of these operators can be reduced to addition and subtraction expressions, which would destroy operator priority, so shifting is correct here.
+[Eq, NEq]
-3) Exp1 followed by (+,-) 2 conflicts:
-In both these cases Exp1 could be reduced together with another Exp1 and a comparative operator to an Exp, but just as in the above case this would be very bad for operator priority, so shifting is right here.
+T+ e1 Eq e2:bool <= T+ e1:t & T+ e2:t
-4) if with else: 1 conflict
-An if statement before the else could be reduced to an if statement lacking the else, but the correct thing is to shift it onto the stack.
+If e1 and e2 are of the same type, then Eq or NEq return bool
-5) if/ifelse/while followed by (;): 3 conflicts
-Here we have redundant semicolons, these could all be reduced to individual statements without the ';'. Such a reduction wouldn't cause any harm, but neither does the shifting, it's an ok choice.
+
+[Plus, Minus, Times, Div]
+
+T+ e1 Plus e2:int <= T+ e1:int & T+ e2:int
+
+The operators Plus/Minus/Times/Div return int if both operands are ints
+
+
+[Lt, ELt, Gt, EGt]
+
+T+ e1 Lt e2:bool <= T+ e1:int & T+ e2:int
+
+The operators Lt/ELt/Gt/EGt return bool if both operands are ints
+
+
+[Assignment]
+
+T+ i := e:t <= i:t in T & T+ e:t
+
+The assignemnt of e to i returns type t if both i and e have type t.
+
+
+[ENeg]
+
+T+ ENeg e:int <= T+ e:int
+
+ENeg e returns int if e is of type int
+
+[ENot]
+
+T+ ENot e:bool <= e:bool
+
+ENot e returns bool if e is of type bool
+
+[EVar]
+
+T+ i:t <= i:t in T
+
+i has type t if i is defined in the context with type t.
+
+[EInt]
+
+T+ n:int
+
+n has type int
+
+[EBool]
+
+T+ b:bool
+
+b has type bool
+
+[EReadI]
+
+T+ n:int
+
+EReadI returns an int
+
+[EReadB]
+
+T+ b:bool
+
+EReadB returns a bool
+
+[EPost]
+
+T+ EPost i:int <= i:int in T
+
+EPost i is of type int if i is defined in T with type int.
+
+[SExp]
+
+T+ e <= T+ e:t
+
+[SBlock]
+
+T+ s;SBlock ss <= T+ s => T' , T'+ ss => T''
+
+the first statment s, in the block, is typechecked in the context T and returns the context T', the rest of the block is then recursively typeckecked in the context T'
+
+
+[SIf]
+
+T+ if e then s1 else s2 <= T+ e:bool & T+ s1 & T+ s2
+
+if e is of type bool and s1 and and s2 typechecks in the context T, then the same context is returned
+
+
+[SWhile]
+
+T+ while e do s <= T+ e:bool & T+ s
+
+If e is of type bool and s typechecks in context T then the same context is returned
+
+
+
+[SDecl]
+
+T+ t i = e => T,i:t <= i not in T & e:t
+
+if i and e are of the same type and i is not declared in the current scope then i is added with type t to the context.
+
+[SDeclD]
+
+T+ t i => T,i:t <= i not in T
+
+if i is not declared in the current scope, then i is added to the context with type t
+
+[SNoop]
+
+T+ s
+
+SNoops does nothing so the same context is returned
+
+[SPrint]
+
+T+ e <= T+ e:t
+
+if e has type t then SPrint returns the same context
projects / proglang.git / blobdiff