Initial import of l3c

[snipe.git] / parse / ast.sml

(* L3 Compiler
 * Abstract Syntax Trees
 * Author: Alex Vaynberg
 * Modified: Frank Pfenning <fp@cs.cmu.edu>
 * Modified: Joshua Wise <jwise@andrew.cmu.edu>
 * Modified: Chris Lu <czl@andrew.cmu.edu>
 *
 * Uses pretty printing library
 * structure PP  -- see util/pp.sml
 *)

signature AST =
sig
  type ident = Symbol.symbol
  
  datatype vtype = Int
  type variable = ident * vtype

  datatype oper = 
     PLUS
   | MINUS
   | TIMES
   | DIVIDEDBY
   | MODULO
   | NEGATIVE			(* unary minus *)
   | LSH
   | RSH
   | LOGOR
   | LOGAND
   | BITAND
   | BITXOR
   | BITOR
   | BITNOT
   | BANG                       (* logical not *)
   | NEQ
   | EQ
   | LT
   | LE
   | GE
   | GT

  datatype exp =
     Var of ident
   | ConstExp of Word32.word
   | OpExp of oper * exp list
   | Marked of (* Kane *) exp Mark.marked
   | FuncCall of ident * (exp list)
  and stm =
     Assign of ident * exp
   | Return of exp
   | Nop
   | Break
   | Continue
   | If of exp * stm list * stm list option
   | For of stm option * exp * stm option * stm list
   | While of exp * stm list
   | MarkedStm of stm Mark.marked

  datatype function =
     Extern of vtype * ident * (variable list)
   | Function of vtype * ident * (variable list) * (variable list) * stm list
  
  type program = function list

  (* print as source, with redundant parentheses *)
  structure Print :
  sig
    val pp_exp : exp -> string
    val pp_stm : stm -> string
    val pp_program : program -> string
  end

end

structure Ast :> AST =
struct
  type ident = Symbol.symbol

  datatype vtype = Int
  type variable = ident * vtype

  datatype oper = 
     PLUS
   | MINUS
   | TIMES
   | DIVIDEDBY
   | MODULO
   | NEGATIVE			(* unary minus *)
   | LSH
   | RSH
   | LOGOR
   | LOGAND
   | BITAND
   | BITXOR
   | BITOR
   | BITNOT
   | BANG
   | NEQ
   | EQ
   | LT
   | LE
   | GE
   | GT

  datatype exp =
     Var of ident
   | ConstExp of Word32.word
   | OpExp of oper * exp list
   | Marked of exp Mark.marked
   | FuncCall of ident * (exp list)
  and stm =
     Assign of ident * exp
   | Return of exp
   | Nop
   | Break
   | Continue
   | If of exp * stm list * stm list option
   | For of stm option * exp * stm option * stm list
   | While of exp * stm list
   | MarkedStm of stm Mark.marked

  datatype function =
     Extern of vtype * ident * (variable list)
   | Function of vtype * ident * (variable list) * (variable list) * stm list
  
  type program = function list

  (* print programs and expressions in source form
   * using redundant parentheses to clarify precedence
   *)
  structure Print =
  struct
    fun pp_ident id = Symbol.name id

    fun pp_oper PLUS = "+"
      | pp_oper MINUS = "-"
      | pp_oper TIMES = "*"
      | pp_oper DIVIDEDBY = "/"
      | pp_oper MODULO = "%"
      | pp_oper NEGATIVE = "-"
      | pp_oper LSH = "<<"
      | pp_oper RSH = ">>"
      | pp_oper LOGAND = "&&"
      | pp_oper LOGOR = "||"
      | pp_oper BITAND = "&"
      | pp_oper BITXOR = "^"
      | pp_oper BITOR = "|"
      | pp_oper BITNOT = "~"
      | pp_oper BANG = "!"
      | pp_oper NEQ = "!="
      | pp_oper EQ = "=="
      | pp_oper LT = "<"
      | pp_oper LE = "<="
      | pp_oper GT = ">"
      | pp_oper GE = ">="

    fun pp_exp (Var(id)) = pp_ident id
      | pp_exp (ConstExp(c)) = Word32Signed.toString c
      | pp_exp (OpExp(oper, [e])) =
	  pp_oper oper ^ "(" ^ pp_exp e ^ ")"
      | pp_exp (OpExp(oper, [e1,e2])) =
	  "(" ^ pp_exp e1 ^ " " ^ pp_oper oper
	  ^ " " ^ pp_exp e2 ^ ")"
      | pp_exp (OpExp(oper, _)) =
          pp_oper oper
      | pp_exp (FuncCall(id, l)) = pp_ident id ^ "(" ^ pp_expl l ^ ")"
      | pp_exp (Marked(marked_exp)) =
	  pp_exp (Mark.data marked_exp)
    
    and pp_expl nil = ""
      | pp_expl (e::a::l) = (pp_exp e) ^ ", " ^ (pp_expl (a::l))
      | pp_expl (e::l) = (pp_exp e) ^ (pp_expl l)

    fun pp_stm (Assign (id,e)) =
	pp_ident id ^ " = " ^ pp_exp e ^ ";"
      | pp_stm (Return e) =
	  "return " ^ pp_exp e ^ ";"
      | pp_stm Nop = ";"
      | pp_stm Break = "break;"
      | pp_stm Continue = "continue;"
      | pp_stm (If (e, s, NONE)) = "if ("^pp_exp e^")"^pp_block s
      | pp_stm (If (e, s, SOME s2)) = "if ("^pp_exp e^")"^pp_block s^" else "^pp_block s2
      | pp_stm (While (e, s)) = "while ("^pp_exp e^") "^pp_block s
      | pp_stm (For (so1, e, so2, s)) = "for ("^ (if (isSome so1) then pp_stm (valOf so1) else "") ^ pp_exp e ^ (if(isSome so2) then pp_stm (valOf so2) else "") ^ ")" ^ pp_block s
      | pp_stm (MarkedStm m) = pp_stm (Mark.data m)

    and pp_block (nil) = ";"
      | pp_block (a::nil) = pp_stm a
      | pp_block (l) = let
          val contents = map pp_stm l
        in
          "{\n" ^ String.concat contents ^ "}\n"
        end

    and pp_stms nil = ""
      | pp_stms (s::ss) = pp_stm s ^ "\n" ^ pp_stms ss
    
    and pp_type Int = "int"
    
    and pp_params nil = ""
      | pp_params ((i, t)::a::l) = (pp_ident i) ^ " : " ^ (pp_type t) ^ ", " ^ (pp_params (a::l))
      | pp_params ((i, t)::l) = (pp_ident i) ^ " : " ^ (pp_type t) ^ (pp_params l)
    
    and pp_vars nil = ""
      | pp_vars ((i, t)::l) = "var " ^ (pp_ident i) ^ " : " ^ (pp_type t) ^ ";\n" ^ (pp_vars l)

    and pp_function (Extern(t, n, pl)) = "extern " ^ (pp_type t) ^ " " ^ (pp_ident n) ^ "(" ^ (pp_params pl) ^ ");\n"
      | pp_function (Function(t, n, pl, vl, stms)) = (pp_type t) ^ " " ^ (pp_ident n) ^ "(" ^ (pp_params pl) ^ ")\n{\n" ^ (pp_vars vl) ^ (String.concat (map pp_stm stms)) ^ "\n}\n"
    
    and pp_program (p) = String.concat (map pp_function p)
  end
end