compilers lab tiger to ir translation

temp.sig

signature TREE =
sig
    datatype binop = PLUS | MINUS | STAR | SLASH | AND | PIPE
    datatype relop = EQ | NEQ | GT | LT | GTE | LTE

    datatype ir = EXPRESSION of expr
                | STATEMENT of stmt
    and expr = CONST of int
                  | NAME  of Temp.label            (* tiger level : functions, destinations for conditionals etc *) (* processor : assembly language address *)
		          | TEMP  of Temp.temp             (* tiger level : variables unbounded number *) (* processor level : processor registers    *)
		          | BINOP of binop * expr * expr
		          | MEM   of expr                  (* processor level : an address's content *)
                  | CALL  of expr * expr list      (* func (arg1, arg2 ....) *)
		          | ESEQ of stmt * expr
    and stmt = MOVE  of expr * expr
             | EXPR  of expr
             | JUMP  of expr * Temp.label list
	         | CJUMP of relop * expr * expr * Temp.label * Temp.label  (* CJUMP rop e1 e2 l1 l2  = if e1 rop e2 then goto l1 else goto l2 *)
	         | SEQ of stmt * stmt
             | LABEL of Temp.label
end

structure Tree : TREE =
struct
    datatype binop = PLUS | MINUS | STAR | SLASH | AND | PIPE
    datatype relop = EQ | NEQ | GT | LT | GTE | LTE

    datatype ir = EXPRESSION of expr
                | STATEMENT of stmt
    and expr = CONST of int
             | NAME  of Temp.label            (* tiger level : functions, destinations for conditionals etc *) (* processor : assembly language address *)
             | TEMP  of Temp.temp             (* tiger level : variables unbounded number *) (* processor level : processor registers    *)
             | BINOP of binop * expr * expr
             | MEM   of expr                  (* processor level : an address's content *)
             | CALL  of expr * expr list      (* func (arg1, arg2 ....) *)
             | ESEQ of stmt * expr
    and stmt = MOVE  of expr * expr
             | EXPR  of expr
             | JUMP  of expr * Temp.label list
	         | CJUMP of relop * expr * expr * Temp.label * Temp.label  (* CJUMP rop e1 e2 l1 l2  = if e1 rop e2 then goto l1 else goto l2 *)
	         | SEQ of stmt * stmt
             | LABEL of Temp.label
end

translate.sml

structure Translate : 
	sig val convert : Tiger.ast -> Tree.ir end =
struct
  
fun convert (e0) =
	let 
		(* fun say s =  TextIO.output(outstream,s) *)
		(* fun sayln s= (say s; say "\n")  *)
  		(* fun indent 0 = () *)
    	  (* | indent i = (say " "; indent(i-1)) *)
  		fun binop Tiger.PLUS = Tree.PLUS
    	  | binop Tiger.MINUS = Tree.MINUS
		  | binop Tiger.STAR = Tree.STAR
		  | binop Tiger.SLASH = Tree.SLASH
          | binop Tiger.AND = Tree.AND
		  | binop Tiger.PIPE = Tree.PIPE
        
        fun relop Tiger.EQ = Tree.EQ
		  | relop Tiger.NEQ = Tree.NEQ
		  | relop Tiger.GT = Tree.GT
		  | relop Tiger.LT = Tree.LT
		  | relop Tiger.GTE = Tree.GTE
		  | relop Tiger.LTE = Tree.LTE

		fun dolist f [a] = f(a)
		  | dolist f (a::r) = (f(a); dolist f r)
		  | dolist f nil = ()

  		fun expr(Tiger.Nil) = (let 
                                   val tmp = Temp.newtemp()
                               in
                                   Tree.EXPRESSION(Tree.ESEQ(Tree.MOVE(Tree.TEMP tmp, Tree.CONST 0), Tree.TEMP tmp))
                               end)
		  | expr(Tiger.Int i, d) = (indent d; say "Int("; say(Int.toString i); say ")")
          (*
		  | expr(Tiger.Str(s),d) = (indent d; say "Str("; say s; say ")")
		  | expr(Tiger.ArrayCreate{arrayType,arraySize,arrayInit},d) = (indent d; say "ArrayCreate("; say(arrayType); sayln ","; expr(arraySize,d+1); sayln ","; expr(arrayInit,d+1); say ")")
		  | expr(Tiger.RecordCreate{recordType,recordElem},d) =
				let fun f((name,e),d) = (indent d; say "("; say(name); sayln ","; expr(e,d+1); say ")")
				in indent d; say "RecordCreate("; say(recordType); sayln ",["; dolist d f recordElem; say "])" 
				end
		  | expr(Tiger.New(s), d) = (indent d; say "New("; say(s); say")")
		  | expr(Tiger.LValue(l), d) = (indent d; sayln "LValue("; lValue(l, d); say")")
		  | expr(Tiger.Func{funcName,args},d) = (indent d; say "Func("; say(funcName); sayln ",["; dolist d expr args; say "])")
		  | expr(Tiger.MethodCall{objectName, methodName, args}, d) = (indent d; sayln "MethodCall("; lValue(objectName, d+1); say","; say(methodName); sayln ","; expr(Tiger.List(args), d+1); say")") *)
		  (* | expr(Tiger.UOpr{operator,left},d) = (indent d; say "UOpr("; say(uopname operator); sayln ","; expr(left, d+1); say")")
		  | expr(Tiger.BOpr{left,operator,right},d) = (indent d; say "BOpr("; say(bopname operator); sayln ","; expr(left,d+1); sayln ","; expr(right,d+1); say ")")
		  | expr(Tiger.List(l), d) = (indent d; say "List"; say "["; dolist d expr l; say "]")
		  | expr(Tiger.Assignment{left=v,right=e},d) = (indent d; sayln "Assignment("; lValue(v,d+1); sayln ","; expr(e,d+1); say ")")
		  | expr(Tiger.IfElse{condition,thenBody},d) = (indent d; sayln "IfElse("; expr(condition,d+1); sayln ","; expr(thenBody,d+1); say ")")
		  | expr(Tiger.IfElseThen{condition,thenBody,elseBody},d) = (indent d; sayln "IfElseThen("; expr(condition,d+1); sayln ","; expr(thenBody,d+1); (sayln ","; expr(elseBody,d+1)); say ")")
		  | expr(Tiger.While{condition,doBody},d) = (indent d; sayln "While("; expr(condition,d+1); sayln ","; expr(doBody,d+1); say ")")
		  | expr(Tiger.Break, d) = (indent d; say "Break")
		  | expr(Tiger.For{counterName=v,from,to,doBody},d) = (indent d; sayln "For("; say(v); sayln ","; expr(from,d+1); sayln ","; expr(to,d+1); sayln ","; expr(doBody,d+1); say ")")
		  | expr(Tiger.Let{letBody,inBody},d) = (indent d; say "Let(["; decs(letBody, d+1); say "],"; dolist d expr inBody; say")")

		and lValue(Tiger.Variable(s),d) = (indent d; say "Variable("; say(s); say ")")
		  | lValue(Tiger.Label(v,s),d) = (indent d; sayln "Label("; lValue(v,d+1); sayln ","; say(s); say ")")
		  | lValue(Tiger.Elem(v,e),d) = (indent d; sayln "Elem("; lValue(v,d+1); sayln ","; expr(e,d+1); say ")")

  		and decs(l, d) = (indent d; say "Seq["; dolist d dec l; say "]")

  		and dec(Tiger.Type (name, ty), d) = (indent d; say "Type("; say(name); sayln ","; types(ty, d+1); say")")
		  | dec(Tiger.Class {className, classBody}, d) = (indent d; say"Class("; say (className); sayln ","; classes(Tiger.classList(classBody), d+1); say")")
		  | dec(Tiger.ClassExt {className, classExtend, classBody}, d) = (indent d; say"Class("; say (className); say ","; say (classExtend); sayln ","; classes(Tiger.classList(classBody), d+1); say")")
		  | dec(Tiger.DecVardec(v),d) = (indent d; sayln "DecVardec("; vardec(v, d+1); say ")")
		  | dec(Tiger.Function{funcName, funcArgs, funcBody}, d) = (indent d; sayln "Function["; types(Tiger.RecordType(funcArgs), d+1); sayln ","; expr(funcBody, d+1); say "]")
		  | dec(Tiger.FunctionOut{funcName, funcArgs, funcOutput, funcBody}, d) = (indent d; sayln "Function("; types(Tiger.RecordType(funcArgs), d+1); say ","; sayln (funcOutput); expr(funcBody, d+1); say ")")
		  | dec(Tiger.Primitive{primName, primArgs}, d) = (indent d; say "Primitive("; say(primName); sayln ","; types(Tiger.RecordType(primArgs), d+1); say ")")
		  | dec(Tiger.PrimitiveOut{primName, primArgs, primOutput}, d) = (indent d; say "PrimitiveOut("; say(primName); sayln ","; types(Tiger.RecordType(primArgs), d+1); say ","; say (primOutput); say ")")
		  | dec(Tiger.Import{importName}, d) = (indent d; say "Import("; say (importName); say ")")
		  

  		and vardec(Tiger.Vardec{variableName, right}, d) = (indent d; say "Vardec("; say (variableName); sayln ","; expr(right, d+1); say")")
  		  | vardec(Tiger.VardecTy{variableName, variableType, right}, d) = (indent d; say "Vardec("; say (variableName); say ","; sayln (variableType); expr(right, d+1); say")")

		and classes(Tiger.classList(l), d) = (indent d; say "classlist["; dolist d class l; say "]")

		and class(Tiger.ClassVardec(v), d) = (indent d; sayln "ClassVardec("; vardec(v, d+1); say ")")
		  | class(Tiger.Method{methodId, methodArgs, right}, d) = (indent d; say "Method("; sayln (methodId); types(Tiger.RecordType(methodArgs), d+1); sayln ","; expr(right, d+1); say")")
		  | class(Tiger.MethodOut{methodId, methodArgs, methodOut, right}, d) = (indent d; say "MethodOut("; sayln (methodId); types(Tiger.RecordType(methodArgs), d+1); say ","; say (methodOut); sayln ","; expr(right, d+1); say")") 

  		and types(Tiger.TypeVar(s), d) = (indent d; say "TypeVar("; say(s); say ")")
    	  | types(Tiger.RecordType l, d) =  (indent d; ty(Tiger.RecordTypeOpt(l), d))
    	  | types(Tiger.arrayType(s),d) = (indent d; say "arrayType("; say(s); say ")")
		  | types(Tiger.ClassExtends{classExtendsBody}, d) = (indent d; sayln "ClassExtends("; classes(Tiger.classList(classExtendsBody), d+1); say")")
		  | types(Tiger.ClassExtendsTy{classExtendsType, classExtendsBody}, d) = (indent d; say "ClassExtendsTy("; say (classExtendsType); sayln ","; classes(Tiger.classList(classExtendsBody), d+1); say")")
		and ty(Tiger.RecordTypeOpt(l), d) = 
			let fun f({name,typ},d) = (indent d; say "("; say (name); say ","; say (typ); say ")")
			in indent d; say "RecordType["; dolist d f l; say "]"
			end *)
	in  
		case e0 of Tiger.Expr (e) =>  expr(e)
                 (* | Tiger.Decs (d) =>  decs(d); *)
	end
end