####### DOCUMENTATIATOIAITAT ION ########
+Functions has been added, with c style syntax.
-Files:
-Typechecker.hs: Simple modification of the bnfc-generated Testsyntax which calls the type-checking functions.
-
-Typecheck.hs: Contains the type-checking functions typeCheckExp, typeCheckVar and typeCheckStm and some utility functions, responsible for the entire type-checking process.
-
-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.
-
-
-typing rules
-++++++++++++
-
-
-(t is used for types, T is the context, and + is used for in)
-
-
-[Eq, NEq]
-
-T+ e1 Eq e2:bool <= T+ e1:t & T+ e2:t
-
-If e1 and e2 are of the same type, then Eq or NEq return bool
-
-
-[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
+Usage:
+./CompInt [-c] [file]
-[Assignment]
+-c : Compile [file], interprets if it isn't specified
-T+ i := e:t <= i:t in T & T+ e:t
+if no arguments are specified then the file is interpreted
-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
+Files:
+Interpret.hs: Handles the interpretation of a program
-b has type bool
+Compile.hs: Compiles the program into a c program
-[EReadI]
+Typechecker.hs: Simple modification of the bnfc-generated Testsyntax which calls the type-checking functions.
-T+ n:int
+Typecheck.hs: Contains the type-checking functions typeCheckExp, typeCheckVar and typeCheckStm and some utility functions, responsible for the entire type-checking process.
-EReadI returns an int
+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.
-[EReadB]
-T+ b:bool
+Additions which comes from the extension:
-EReadB returns a bool
+typing rules
+++++++++++++
-[EPost]
+(t is used for types, T is the context, and + is used for in)
-T+ EPost i:int <= i:int in T
+[EFunc]
-EPost i is of type int if i is defined in T with type int.
+T+ i (es) : t <= i(ts):t in T & T+ es:ts
-[SExp]
+The functioncall of i returns t if i is in the context with returntype t and the types of the argument expressions matches those in the parameter list
-T+ e <= T+ e:t
+[SReturn]
-[SBlock]
+T+ return e <= e:t & ret(t) in T
-T+ s;SBlock ss <= T+ s => T' , T'+ ss => T''
+return typechecks if e returns the same type as the current context
-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'
+[Func]
+T+ t i (ds) => T' <= ds:ts & T,i(ts):t => T'
-[SIf]
+Adds the function with parameter types and returntype to the context
-T+ if e then s1 else s2 <= T+ e:bool & T+ s1 & T+ s2
+T+ t i (ds) ss <= T,novariables,ret(t),ds => T' & T'+ss & last(ss) => return:t
-if e is of type bool and s1 and and s2 typechecks in the context T, then the same context is returned
+the function i typechecks if the body typechecks in the context where all other variables has been removed and the return type and paramters has been added and that the last statement is a return with the right type
+[Program]
-[SWhile]
+T+ fs ss <= T+,fs => T' && T'+ fs && T'+ ss
-T+ while e do s <= T+ e:bool & T+ s
+The program typechecks if all the functions and all the statements typechecks in the context with all functions added to it.
-If e is of type bool and s typechecks in context T then the same context is returned
+semantic rules
+++++++++++++
+(v is used for values, e for expressions, s for statements, c is the context)
+[EFunc]
-[SDecl]
+<i (es), c> => <o'''(ret),o'> <= <es,c> => <vs,c'>, c(i) => <ds,ss>, c'[clearVars,ds->vs] => c'' <ss,o''> => o'''
-T+ t i = e => T,i:t <= i not in T & e:t
+Evaluate the arguments in order, find function definition, remove the old variables and add values from the arguments to the parameters. execute the body until retun. Return the value from the return state and the state from the argument expressions.
-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]
+[SReturn]
-T+ t i => T,i:t <= i not in T
+<return e,c> <= <e,c> => <v,c'>, c'[ret->v], STOP
-if i is not declared in the current scope, then i is added to the context with type t
+Evaluate the expression, add the value as return value to the state and stop the execution of the state
-[SNoop]
+[Func]
-T+ s
+<t i (ds) ss, c> => c[i-><ds,ss>]
-SNoops does nothing so the same context is returned
+Adds the function i with parameters ds and body ss to the context
-[SPrint]
+[Program]
-T+ e <= T+ e:t
+<fs ss, c> => c'' <= c[fs] => c', <ss,c'> => c''
-if e has type t then SPrint returns the same context
+Add all the function to the context and execute the statements in this context
projects / proglang.git / blobdiff