bill/compiler_proj3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
bill
2023-09-18 07:17:49 -04:00
parent acf15f81fe
commit ebae52c4df
6 changed files with 363 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
proj3/.gitignore
+10
View File
@@ -0,0 +1,10 @@
.vscode
.DS_Store
.bloop
.metals
**/target
**/.bloop
**/.metals
gen/*
!gen/bootstrap.c
metals.*
proj3/src/main/scala/project3/Compiler.scala
+87 -11
View File
@@ -52,7 +52,9 @@ abstract class X86Compiler extends BugReporter with Codegen {
*/
val primitives = Map(
"putchar" -> Func("putchar"),
"getchar" -> Func("getchar"))
"getchar" -> Func("getchar"),
"toInt" -> Func("toInt"),
"toChar" -> Func("toChar"))
private class Env {
def undef(name: String) = BUG(s"Undefined identifier $name (should have been found during the semantic analysis)")
@@ -124,6 +126,28 @@ abstract class X86Compiler extends BugReporter with Codegen {
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"sete %al")
emitln(s"movzbq %al, ${loc(sp)}")
case "!=" =>
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"setne %al")
emitln(s"movzbq %al, ${loc(sp)}")
case ">=" =>
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"setge %al")
emitln(s"movzbq %al, ${loc(sp)}")
case ">" =>
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"setg %al")
emitln(s"movzbq %al, ${loc(sp)}")
case "<=" =>
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"setle %al")
emitln(s"movzbq %al, ${loc(sp)}")
case "<" =>
emitln(s"cmp ${loc(sp1)}, ${loc(sp)}")
emitln(s"setl %al")
emitln(s"movzbq %al, ${loc(sp)}")
case "block-get" =>
emitln(s"movq (${loc(sp)}, ${loc(sp1)}, 8), ${loc(sp)}")
case _ => BUG(s"Binary operator $op undefined")
}
@@ -136,6 +160,9 @@ abstract class X86Compiler extends BugReporter with Codegen {
* Valid operators: block-set
*/
def transTer(op: String)(sp: Loc, sp1: Loc, sp2: Loc) = op match {
case "block-set" =>
emitln(s"movq ${loc(sp2)}, (${loc(sp)}, ${loc(sp1)}, 8)")
emitln(s"movq ${loc(sp2)}, ${loc(sp)}") // returns rhs
case _ => BUG(s"ternary operator $op undefined")
}
@@ -173,7 +200,9 @@ abstract class X86Compiler extends BugReporter with Codegen {
* if the location 'sp' contains the value 'true'
*/
def transJumpIfTrue(sp: Loc)(label: Label) = {
???
emitln(s"movq $$1, ${loc(sp + 1)}")
emitln(s"cmp ${loc(sp)}, ${loc(sp + 1)}")
emitln(s"je $label")
}
/*
@@ -188,7 +217,13 @@ abstract class X86Compiler extends BugReporter with Codegen {
def trans(exp: Exp, sp: Loc)(env: LocationEnv): Unit = exp match {
case Lit(x: Int) =>
emitln(s"movq $$$x, ${loc(sp)}")
case Lit(b: Boolean) => () // TODO
case Lit(x: Char) =>
emitln(s"movq $$${x.toInt}, ${loc(sp)}")
case Lit(b: Boolean) => // TODO
if(b)
emitln(s"movq $$1, ${loc(sp)}")
else
emitln(s"movq $$0, ${loc(sp)}")
case Lit(x: Unit) => () // TODO
case Prim(op, args) =>
val idxs = List.tabulate(args.length)(i => sp + i)
@@ -205,7 +240,7 @@ abstract class X86Compiler extends BugReporter with Codegen {
case Ref(x) =>
env(x) match {
case Reg(sp1) => emitln(s"movq ${loc(sp1)}, ${loc(sp)}")
case Func(name) => ??? // Extra credit
case Func(name) => emitln(s"leaq ${funcName(name)}(%rip), ${loc(sp)}") // Extra credit
}
case If(cond, tBranch, eBranch) =>
val lab = freshLabel("if")
@@ -233,12 +268,24 @@ abstract class X86Compiler extends BugReporter with Codegen {
transJumpIfTrue(sp)(s"${lab}_body")
trans(body, sp)(env)
case LetRec(funs, body) =>
emitln(s"${funcName("toInt")}:", 0)
emitln(s"movzbq %dil, %rax")
emitln(s"ret\n")
emitln(s"${funcName("toChar")}:", 0)
emitln(s"movzbq %dil, %rax")
emitln("ret\n")
emitln("################# FUNCTIONS #####################", 0)
// We do not save the location of the function into register because we can use their
// name as a label.
val funsLoc = funs map { case FunDef(name, _, _, _) => (name, Func(name)) }
// TODO complete the code
funs map {
case func@FunDef(_, _, _, _) =>
trans(func, Reg(0))(env.withVals(funsLoc))
}
emitln("#################################################\n\n", 0)
emitln("###################### MAIN #####################", 0)
@@ -257,7 +304,8 @@ abstract class X86Compiler extends BugReporter with Codegen {
// emit the main function (body of LetRec) here
// TODO you may need to change that code.
trans(body, Reg(0))(LocationEnv())
trans(body, Reg(0))(LocationEnv().withVals(funsLoc))
emitln(s"movq ${loc(0)}, %rax")
//////////// DO NOT CHANGE////////////////
@@ -280,6 +328,10 @@ abstract class X86Compiler extends BugReporter with Codegen {
//////////////////////////////////////////
// TODO
val ids = (0 until args.length).toList
val arg_regs = (args zip ids) map {case (Arg(fname, _, _), idx) => (fname, sp + idx)}
trans(fbody, sp + args.length)(env.withVals(arg_regs))
emitln(s"movq ${loc(sp + args.length)}, %rax")
//////////// DO NOT CHANGE////////////////
emitln("movq %rbp, %rsp\t# reset frame")
@@ -292,27 +344,51 @@ abstract class X86Compiler extends BugReporter with Codegen {
// code and work on multiple arguments.
// Evaluate the arguments
// TODO
val ids = (0 until args.length).toList
(args zip ids) map {case (arg, idx) => trans(arg, sp + idx)(env)}
// Compute the physical location of the function to be called
val fLoc: String = fun match {
case Ref(fname) =>
env(fname) match {
case Reg(sp) => ??? // Extra credit
case Func(name) => "" // TODO
case Reg(sp) => s"*${loc(sp)}" // Extra credit
case Func(name) => funcName(name) // TODO
}
case _ => ??? // Extra credit
case _ => // return from another invocation
trans(fun, sp)(env);
s"*${loc(sp)}"
}
// Implement the calling conventions after that point
// and generate the function call
// TODO
()
val spID : Int = sp match {
case Reg(i) => i
}
for(i <- 0 to spID){
emitln(s"pushq ${loc(i)}");
}
for(i <- 0 to spID) {
emitln(s"movq ${loc(sp + i)}, ${loc(i)}")
}
emitln(s"call ${fLoc}")
for(i <- spID to 0 by -1) {
emitln(s"popq ${loc(i)}");
}
emitln(s"movq %rax, ${loc(sp)}")
case ArrayDec(size, _) =>
// This node needs to allocate an area of eval(size) * 8 bytes in the heap
// the assembly variable "heap" contains a pointer to the first valid byte
// in the heap. Make sure to update its value accordingly.
// TODO
()
emitln(s"movq (%rip), ${loc(sp)}")
trans(size, sp + 1)(env)
emitln(s"movq (%rip), ${loc(sp + 2)}")
emitln(s"movq (${loc(sp + 2)}, ${loc(sp + 1)}, 8), ${loc(sp + 2)}")
emitln(s"movq ${loc(sp + 2)}, %rip")
case _ => BUG(s"don't know how to implement $exp")
}
}
proj3/src/main/scala/project3/Interpreter.scala
+62 -11
View File
@@ -19,7 +19,9 @@ class ValueInterpreter extends Interpreter with BugReporter {
*/
val primitives = Map[String, BoxedVal](
"putchar" -> BoxedVal(Primitive("putchar")),
"getchar" -> BoxedVal(Primitive("getchar"))
"getchar" -> BoxedVal(Primitive("getchar")),
"toInt" -> BoxedVal(Primitive("toInt")),
"toChar" -> BoxedVal(Primitive("toChar"))
)
/*
@@ -204,6 +206,12 @@ class ValueInterpreter extends Interpreter with BugReporter {
Console.out.write(c)
Console.out.flush
Cst(())
case Primitive("toInt") =>
val List(Cst(c: Char)) = eargs
Cst(c.toInt)
case Primitive("toChar") =>
val List(Cst(c: Int)) = eargs
Cst(c.toChar)
}
case ArrayDec(size, _) =>
val Cst(s: Int) = eval(size)(env)
@@ -225,7 +233,9 @@ object StackVal extends BugReporter {
*/
val primitives = Map[String, Loc](
"putchar" -> 0,
"getchar" -> 1
"getchar" -> 1,
"toInt" -> 2,
"toChar" -> 3
)
/**
@@ -303,6 +313,8 @@ class StackInterpreter extends Interpreter with BugReporter {
val memory = new Array[Val](1000)
memory(0) = Primitive("putchar")
memory(1) = Primitive("getchar")
memory(2) = Primitive("toInt")
memory(3) = Primitive("toChar")
var flag: Boolean = true
/*
@@ -332,12 +344,15 @@ class StackInterpreter extends Interpreter with BugReporter {
case (">=", Cst(x: Int), Cst(y: Int)) => memory(sp) = Cst(x >= y)
case ("<" , Cst(x: Int), Cst(y: Int)) => memory(sp) = Cst(x < y)
case (">" , Cst(x: Int), Cst(y: Int)) => memory(sp) = Cst(x > y)
case ("block-get", Cst(arr: Array[Any]), Cst(i: Int)) => ???
case ("block-get", Cst(arr: Array[Any]), Cst(i: Int)) =>
if (arr(i) == null)
BUG(s"uninitialized memory")
memory(sp) = Cst(arr(i))
case _ => BUG(s"Binary operator $op undefined")
}
def evalTer(op: String)(sp: Loc, sp1: Loc, sp2: Loc) = (op, memory(sp), memory(sp1), memory(sp2)) match {
case ("block-set", Cst(arr: Array[Any]), Cst(i: Int), Cst(x)) => ???
case ("block-set", Cst(arr: Array[Any]), Cst(i: Int), Cst(x)) => memory(sp) = Cst(arr(i) = x)
case _ => BUG(s"ternary operator $op undefined")
}
@@ -353,9 +368,9 @@ class StackInterpreter extends Interpreter with BugReporter {
* an empty environment and return the value.
*/
def run(exp: Exp): Val = {
// Start at 2, putchar and getchar are store at 0 and 1!!
eval(exp, 2)(LocationEnv())
memory(2)
// Start at 4, putchar, getchar, toChar, toInt are store at 0 and 1, 2, 3!!
eval(exp, 4)(LocationEnv())
memory(4)
}
/*
@@ -405,11 +420,47 @@ class StackInterpreter extends Interpreter with BugReporter {
eval(cond, sp)(env)
}
eval(body, sp)(env)
case FunDef(_, args, _, fbody) => ???
case FunDef(_, args, _, fbody) =>
memory(sp) = Func(args map { arg => (arg.name) }, fbody, env)
case LetRec(funs, body) =>
// TODO modify that code
eval(body, sp)(env)
case App(fun, args) => ???
case ArrayDec(size, _) => ???
val ids = (sp until sp + funs.length).toList
// Evaluate all functions
val funcs = (funs zip ids) map { case (fun@FunDef(name, _, _, _), idx) => (name, idx) }
// Add all functions to the functions environment (recursion)
(funs zip ids) foreach { case (fun@FunDef(_, _, _, _), idx:Int) => eval(fun, idx)(env.withVals(funcs)) }
eval(body, sp + funs.length)(env.withVals(funcs))
memory(sp) = memory(sp + funs.length)
case App(fun, args) =>
val ids = (sp until sp + args.length).toList
(args zip ids) map { case (arg, idx) => eval(arg, idx)(env) }
eval(fun, sp + args.length)(env)
memory(sp + args.length) match {
case Func(fargs, fbody, fenv) =>
eval(fbody, sp + args.length + 1)(fenv.withVals(fargs zip ids))
memory(sp) = memory(sp + args.length + 1)
case Primitive("getchar") =>
memory(sp) = Cst(Console.in.read)
case Primitive("putchar") =>
val List(Cst(c: Int)) = memory(sp)
Console.out.write(c)
Console.out.flush
Cst(())
case Primitive("toInt") =>
val List(Cst(c: Char)) = memory(sp)
memory(sp) = Cst(c.toInt)
case Primitive("toChar") =>
val List(Cst(c: Int)) = memory(sp)
memory(sp) = Cst(c.toChar)
}
case ArrayDec(size, _) =>
eval(size, sp)(env)
val Cst(idx: Int) = memory(sp)
memory(sp) = Cst(new Array[Any](idx))
}
}
proj3/src/main/scala/project3/Main.scala
+1 -2
View File
@@ -41,7 +41,6 @@ OPTION: intStack""")
} else {
args(0)
}
println("============ SRC CODE ============")
println(src)
println("==================================\n")
@@ -51,7 +50,7 @@ OPTION: intStack""")
// Parser to test!
// TODO: Change this as you finish parsers
val parser = new BaseParser(scanner)
val parser = new ArrayParser(scanner)
val ast = try {
parser.parseCode
} catch {
proj3/src/main/scala/project3/Parser.scala
+134 -14
View File
@@ -99,11 +99,11 @@ class Scanner(in: Reader[Char]) extends Reader[Tokens.Token] with Reporter {
// List of delimiters
// TODO: Update this as delimiters are added to our language
val isDelim = Set('(',')','=',';','{','}',':')
val isDelim = Set('(',')','=',';','{','}',':', ',', '[', ']')
// List of keywords
// TODO: Update this as keywords are added to our language
val isKeyword = Set("if", "else", "val", "var", "while")
val isKeyword = Set("if", "else", "val", "var", "while", "def", "=>", "new")
val isBoolean = Set("true", "false")
@@ -119,7 +119,7 @@ class Scanner(in: Reader[Char]) extends Reader[Tokens.Token] with Reporter {
}
val s = buf.toString
if (isKeyword(s)) Keyword(s)
else if (isBoolean(s)) Boolean(s)
else if (isBoolean(s)) Literal(s.toBoolean)
else Ident(s)
}
@@ -169,6 +169,12 @@ class Scanner(in: Reader[Char]) extends Reader[Tokens.Token] with Reporter {
getOperator()
} else if (in.hasNext(isDigit)) {
getNum()
} else if (in.hasNext(Set('\''))) {
in.next()
val s = in.next()
if (in.hasNext(_ == '\'')) in.next()
else expected(s"\'")
Literal(s)
} else if (in.hasNext(isDelim)) {
Delim(in.next())
} else if (!in.hasNext) {
@@ -372,6 +378,7 @@ object Language {
case class ArrayType(tp: Type) extends Type
val IntType = BaseType("Int")
val CharType = BaseType("Char")
val UnitType = BaseType("Unit")
val BooleanType = BaseType("Boolean")
@@ -448,6 +455,18 @@ class BaseParser(in: Scanner) extends Parser(in) {
* TODO: Implement this function
*/
def parseType: Type = in.peek match {
case Ident("Int") =>
in.next()
IntType
case Ident("Char") =>
in.next()
CharType
case Ident("Boolean") =>
in.next()
BooleanType
case Ident("Unit") =>
in.next()
UnitType
case _ => expected("type")
}
@@ -460,6 +479,9 @@ class BaseParser(in: Scanner) extends Parser(in) {
* TODO: Implement this function
*/
def parseOptionalType: Type = in.peek match {
case Delim(':') =>
in.next()
parseType
case _ => UnknownType
}
@@ -626,14 +648,37 @@ class SyntacticSugarParser(in: Scanner) extends BaseParser(in) {
suf + "$" + next
}
override def parseSimpleExpression = in.peek match {
override def parseSimpleExpression = in.peek match { // !!!
case Keyword("if") =>
val pos = in.next().pos
accept('(')
val cond = parseSimpleExpression
accept(')')
val tBranch = parseSimpleExpression
val res = if (in.peek == Keyword("else")) {
in.next()
If(cond, tBranch, parseSimpleExpression).withPos(pos)
} else {
If(cond, tBranch, Lit(Unit)).withPos(pos)
}
res
case _ => super.parseSimpleExpression
}
override def parseExpression = {
// NOTE: parse expression terminates when it parse a simples expression.
// syntax sugar allows to have an other expression after it.
val res = super.parseExpression
// syntax sugar allows to have an other expression after it. !!!
var res = in.peek match {
case Keyword("val") | Keyword("var") | Keyword("while") =>
super.parseExpression
case _ =>
var simp = parseSimpleExpression
if(isNewLine(in.peek)) {
accept(';')
simp = Let(freshName(), UnknownType, simp, parseExpression).withPos(simp.pos)
}
simp
}
res
}
@@ -719,10 +764,30 @@ class FunctionParser(in: Scanner) extends SyntacticSugarParser(in) {
/*
* This function parse types.
*
* TODO
* TODO !!!
*/
override def parseType = in.peek match {
case _ => super.parseType
case Delim('(') =>
accept('(')
val list = parseList[Type](parseType, ',', tok => tok match {
case Delim(')') => false;
case _ => true
})
val argList = list map { tp => ("", tp)}
accept("=>")
val rtp = parseType
FunType(argList, rtp)
case _ =>
val typ = super.parseType
if(in.peek == Delim('=') && in.peek1 == Ident(">")) {
accept("=>")
val rtp = super.parseType
val typList: List[(String, Type)] = List(("", typ))
FunType(typList, rtp)
}
else {
typ
}
}
/*
@@ -742,7 +807,9 @@ class FunctionParser(in: Scanner) extends SyntacticSugarParser(in) {
* TODO: complete the function
*/
def parseArg: Arg = {
???
val (arg, pos) = getName()
val ty = parseOptionalType
Arg(arg, ty, pos)
}
/*
@@ -752,7 +819,16 @@ class FunctionParser(in: Scanner) extends SyntacticSugarParser(in) {
* TODO: complete the function
*/
def parseFunction: Exp = {
???
accept("def")
val (fname, pos) = getName()
accept('(')
val args = parseList[Arg](parseArg, ',', _ match {
case Ident(_) => true; case _ => false
})
accept(')')
val retTy = parseOptionalType
accept('=')
FunDef(fname, args, retTy, parseSimpleExpression).withPos(pos)
}
/*
@@ -765,6 +841,12 @@ class FunctionParser(in: Scanner) extends SyntacticSugarParser(in) {
* TODO: complete the function
*/
def parseProgram = in.peek match {
case Keyword("def") =>
val fns = parseList[Exp](parseFunction, ';', _ match {
case Keyword("def") => true; case _ => false
})
accept(';')
LetRec(fns, parseExpression)
case _ => LetRec(Nil, parseExpression)
}
@@ -798,7 +880,15 @@ class FunctionParser(in: Scanner) extends SyntacticSugarParser(in) {
res
case _ =>
var res = parseAtom
// TODO: complete
while(in.peek == Delim('(')) {
val pos = in.next().pos
val params = parseList[Exp](parseSimpleExpression, ',', _ match {
case Delim(')') => false; case _ => true
})
accept(')')
res = App(res, params).withPos(pos)
}
// Done: completed
res
}
@@ -865,7 +955,12 @@ class ArrayParser(in: Scanner) extends FunctionParser(in) {
import Tokens._
override def parseType = in.peek match {
case Ident("Array") => ???
case Ident("Array") =>
in.next()
accept('[')
val ty = parseType
accept(']')
ArrayType(ty)
case _ => super.parseType
}
@@ -874,12 +969,37 @@ class ArrayParser(in: Scanner) extends FunctionParser(in) {
*
* TODO
*/
override def parseTight = ???
override def parseTight : Exp = {
val lhs = super.parseTight
if (in.peek == Delim('=')) {
accept('=')
lhs match {
case App(arr, List(idx)) =>
Prim("block-set", List(arr, idx, parseSimpleExpression)).withPos(lhs.pos)
case _ =>
error("Unsupported assignment")
lhs
}
}
else
lhs
}
/*
* Parse array declaration
*
* TODO
*/
override def parseSimpleExpression = ???
override def parseSimpleExpression = in.peek match {
case Keyword("new") =>
val pos = in.next().pos
val ty = parseType
accept('(')
val expr = parseSimpleExpression
accept(')')
ArrayDec(expr, ty).withPos(pos)
case _ =>
super.parseSimpleExpression
}
}
proj3/src/main/scala/project3/SemanticAnalyzer.scala
+69 -20
View File
@@ -7,6 +7,8 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
* Primitive functions that do not need to be defined or declared.
*/
val primitives = Map[String,(Boolean,Type)](
"toInt" -> (false, FunType(List(("", CharType)), IntType)),
"toChar" -> (false, FunType(List(("", IntType)), CharType)),
"getchar" -> (false, FunType(List(), IntType)),
"putchar" -> (false, FunType(List(("", IntType)), UnitType))
)
@@ -163,7 +165,10 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
* TODO: implement the remaining binary operators for typeBinOperator
*/
def typeBinOperator(op: String)(pos: Position) = op match {
case "+" => FunType(List(("", IntType), ("", IntType)), IntType)
case "+" | "-" | "*" | "/" =>
FunType(List(("", IntType), ("", IntType)), IntType)
case ">=" | "<=" | ">" | "<" | "==" | "!=" =>
FunType(List(("", IntType), ("", IntType)), BooleanType)
case _ =>
error("undefined binary operator", pos)
UnknownType
@@ -177,6 +182,8 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
* TODO: implement typeUnOperator
*/
def typeUnOperator(op: String)(pos: Position) = op match {
case "+" | "-" => FunType(List(("", IntType)), IntType)
// case "!" => FunType(List(("", BooleanType)), BooleanType)
case _ =>
error(s"undefined unary operator", pos)
UnknownType
@@ -188,6 +195,8 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
* operators: block-set
*/
def typeTerOperator(op: String)(pos: Position) = op match {
case "block-set" =>
FunType(List(("", ArrayType(IntType)), ("", IntType)), IntType)
case _ =>
error(s"undefined ternary operator", pos)
UnknownType
@@ -215,7 +224,8 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
case (_, UnknownType) => typeWellFormed(tp)(env, pos) // tp <: Any
case (UnknownType, _) => typeWellFormed(pt)(env, pos) // for function arguments
case (FunType(args1, rtp1), FunType(args2, rtp2)) if args1.length == args2.length =>
??? // TODO: Function type conformity
FunType(typeConform(args1, args2)(env, pos), typeConforms(rtp1, rtp2)(env, pos))
// Done: Function type conformity
case (ArrayType(tp), ArrayType(pt)) => ArrayType(typeConforms(tp, pt)(env, pos))
case _ => error(s"type mismatch;\nfound : $tp\nexpected: $pt", pos); pt
}
@@ -281,12 +291,22 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
def typeInfer(exp: Exp, pt: Type)(env: TypeEnv): Exp = exp match {
case Lit(_: Int) => exp.withType(IntType)
case Lit(_: Boolean) => ???
case Lit(_: Unit) => ???
case Prim("block-set", args) => ???
case Lit(_: Boolean) => exp.withType(BooleanType)
case Lit(_: Char) => exp.withType(CharType)
case Lit(_: Unit) => exp.withType(UnitType)
case Prim("block-set", args) =>
Prim("block-set", List(
typeCheck(args(0), ArrayType(pt))(env),
typeCheck(args(1), IntType)(env),
typeCheck(args(2), pt)(env)
)).withType(UnitType)
case Prim(op, args) =>
typeOperator(op, args.length)(exp.pos) match {
case FunType(atps, rtp) => ???
case FunType(atps, rtp) =>
val args_checked = (args zip atps) map {
case (arg, (_, param)) => typeCheck(arg, param)(env)
}
Prim(op, args_checked).withType(rtp)
case UnknownType => exp.withType(UnknownType)
case _ => BUG("operator's type needs to be FunType")
}
@@ -298,18 +318,28 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
Let(x, nrhs.tp, nrhs, nbody).withType(nbody.tp)
case Ref(x) =>
env(x) match {
case Some(tp) => ??? // Remember to check that the type taken from the environment is welformed
case Some(tp) =>
exp.withType(typeWellFormed(tp)(env, exp.pos))
// Remember to check that the type taken from the environment is wellformed
case _ =>
error("undefined identifier", exp.pos)
???
exp.withType(UnknownType)
}
case If(cond, tBranch, eBranch) =>
// Hint: type check the else branch before the then branch.
???
val condChecked = typeCheck(cond, BooleanType)(env)
val elseChecked = typeCheck(eBranch, pt)(env)
val thenChecked = typeCheck(tBranch, elseChecked.tp)(env)
If(condChecked, thenChecked, elseChecked).withType(elseChecked.tp)
case VarDec(x, tp, rhs, body) =>
if (env.isDefined(x))
warn("reuse of variable name", exp.pos)
???
val rhsChecked = typeCheck(rhs, tp)(env)
val _env = env.withVar(x, rhsChecked.tp)
val bodyChecked = typeCheck(body, pt)(_env)
VarDec(x, rhsChecked.tp, rhsChecked, bodyChecked).withType(bodyChecked.tp)
case VarAssign(x, rhs) =>
val xtp = if (!env.isDefined(x)) {
error("undefined identifier", exp.pos)
@@ -320,7 +350,7 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
env(x).get
}
???
val rhsChecked = typeCheck(rhs, xtp)(env)
/* Because of syntactic sugar, a variable assignment
* statement can be accepted as an expression
@@ -338,18 +368,35 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
* Without changing the semantics!
*/
pt match {
case UnitType => ???
case _ => ???
case UnitType | IntType | BooleanType | CharType => VarAssign(x, rhsChecked).withType(rhsChecked.tp)
case _ => exp.withType(UnknownType)
}
case While(cond, lbody, body) => ???
case FunDef(fname, args, rtp, fbody) => ???
case While(cond, lbody, body) =>
val condChecked = typeCheck(cond, BooleanType)(env)
val lbodyChecked = typeCheck(lbody, UnitType)(env)
val bodyChecked = typeCheck(body, pt)(env)
While(condChecked, lbodyChecked, bodyChecked).withType(bodyChecked.tp)
case FunDef(fname, args, rtp, fbody) =>
checkDuplicateNames(args)
val argsWType = args map {
a => (a.name, typeWellFormed(a.tp)(env, a.pos))
}
val bodyChecked = typeCheck(fbody, rtp)(env.withVals(argsWType)) // check rtp w/ pt?
FunDef(fname, args, bodyChecked.tp, bodyChecked).withType(
FunType(argsWType, bodyChecked.tp)
)
case LetRec(funs, body) =>
// TODO modify to handle general case
val nbody = typeCheck(body, pt)(env)
LetRec(Nil, nbody).withType(nbody.tp)
val _env = env.withVals(funs.map {case FunDef(name, _, rtp, _) => (name, rtp)})
val funsChecked = funs map {case f@FunDef(_, _, rtp, _) => typeCheck(f, rtp)(_env) }
val bodyChecked = typeCheck(body, pt)( env.withVals(funsChecked map {case FunDef(name, _, rtp, _) => (name, rtp)}))
LetRec(funsChecked, bodyChecked).withType(bodyChecked.tp)
case App(fun, args) =>
// TODO Check fun type
val nFun: Exp = ???
val nFun: Exp = typeCheck(fun, fun.tp)(env)
// Handling some errors
val ftp = nFun.tp match {
@@ -369,7 +416,9 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
}
// TODO: Check arguments type
val nargs: List[Exp] = ???
val nargs: List[Exp] = (args zip ftp.args) map {
case (arg, (_, param)) => typeCheck(arg, param)(env)
}
// Transform some function applications into primitives on arrays.
nFun.tp match {
@@ -380,7 +429,7 @@ class SemanticAnalyzer(parser: Parser) extends Reporter with BugReporter {
case ArrayDec(size: Exp, etp: Type) =>
// TODO: Check array declaration
// Note that etp is the type of elements
???
ArrayDec(typeCheck(size, IntType)(env), etp).withType(etp)
case _ => BUG(s"malformed expresstion $exp")
}
}