source: Deliverables/D2.2/8051/src/cminor/cminorPrinter.ml @ 740

open AST

let print_type = function
  | Sig_int -> "int"
  | Sig_float -> "float"
  | Sig_ptr -> "ptr"

let print_ret_type = function
  | Type_ret t -> print_type t
  | Type_void -> "void"

let print_sig sg =
  let rec aux = function
    | [] -> ""
    | [t] -> (print_type t) ^ " -> "
    | t :: sg -> (print_type t) ^ " -> " ^ (aux sg)
  in
  (aux sg.args) ^ (print_ret_type sg.res)


let print_data = function
  | Data_reserve n -> Printf.sprintf "[%d]" n
  | Data_int8 i -> Printf.sprintf "(int8) %d" i
  | Data_int16 i -> Printf.sprintf "(int16) %d" i
  | Data_int32 i -> Printf.sprintf "%d" i
  | Data_float32 f -> Printf.sprintf "%f" f
  | Data_float64 f -> Printf.sprintf "(float64) %f" f

let print_datas init =
  let rec aux = function
    | [] -> ""
    | [data] -> print_data data
    | data :: datas -> Printf.sprintf "%s, %s" (print_data data) (aux datas)
  in
  Printf.sprintf "{%s}" (aux init)

let print_var (id, init) =
  Printf.sprintf "var \"%s\" %s\n" id (print_datas init)

let print_vars = List.fold_left (fun s v -> s ^ (print_var v)) ""

let print_constant = function
  | Cst_int i -> string_of_int i
  | Cst_float f -> string_of_float f
  | Cst_addrsymbol id -> "\"" ^ id ^ "\""
  | Cst_stackoffset off -> "&" ^ (string_of_int off)

let print_cmp = function
  | Cmp_eq -> "=="
  | Cmp_ne -> "!="
  | Cmp_gt -> ">"
  | Cmp_ge -> ">="
  | Cmp_lt -> "<"
  | Cmp_le -> "<="

let print_op1 = function
  | Op_cast8unsigned -> "int8u"
  | Op_cast8signed -> "int8s"
  | Op_cast16unsigned -> "int16u"
  | Op_cast16signed -> "int16s"
  | Op_negint -> "-"
  | Op_notbool -> "!"
  | Op_notint -> "~"
  | Op_negf -> "-f"
  | Op_absf -> "absf"
  | Op_singleoffloat -> "float32"
  | Op_intoffloat -> "intoffloat"
  | Op_intuoffloat -> "intuoffloat"
  | Op_floatofint -> "floatofint"
  | Op_floatofintu -> "floatofintu"
  | Op_id -> ""
  | Op_intofptr -> "intofptr"
  | Op_ptrofint -> "ptrofint"

let print_op2 = function
  | Op_add -> "+"
  | Op_sub -> "-"
  | Op_mul -> "*"
  | Op_div -> "/"
  | Op_divu -> "/u"
  | Op_mod -> "%"
  | Op_modu -> "%u"
  | Op_and -> "&&"
  | Op_or -> "||"
  | Op_xor -> "^"
  | Op_shl -> "<<"
  | Op_shr -> ">>"
  | Op_shru -> ">>u"
  | Op_addf -> "+f"
  | Op_subf -> "-f"
  | Op_mulf -> "*f"
  | Op_divf -> "/f"
  | Op_cmp cmp -> print_cmp cmp
  | Op_cmpu cmp -> (print_cmp cmp) ^ "u"
  | Op_cmpf cmp -> (print_cmp cmp) ^ "f"
  | Op_addp -> "+p"
  | Op_subp -> "-p"
  | Op_cmpp cmp -> (print_cmp cmp) ^ "p"

let rec print_expression = function
  | Cminor.Id id -> id
  | Cminor.Cst cst -> print_constant cst
  | Cminor.Op1 (op1, e) ->
      Printf.sprintf "%s%s" (print_op1 op1) (add_parenthesis e)
  | Cminor.Op2 (op2, e1, e2) ->
      Printf.sprintf "%s %s %s"
        (add_parenthesis e1)
        (print_op2 op2)
        (add_parenthesis e2)
  | Cminor.Mem (q, e) ->
      Printf.sprintf "%s[%s]" (Memory.string_of_quantity q) (print_expression e)
  | Cminor.Cond (e1, e2, e3) ->
      Printf.sprintf "%s ? %s : %s"
        (add_parenthesis e1)
        (add_parenthesis e2)
        (add_parenthesis e3)
  | Cminor.Exp_cost (lab, e) ->
      Printf.sprintf "/* %s */ %s" lab (print_expression e)
and add_parenthesis e = match e with
  | Cminor.Id _ | Cminor.Cst _ | Cminor.Mem _ -> print_expression e
  | _ -> Printf.sprintf "(%s)" (print_expression e)


let rec print_args = function
  | [] -> ""
  | [e] -> print_expression e
  | e :: args -> (print_expression e) ^ ", " ^ (print_args args)


let n_spaces n = String.make n ' '


let print_locals vars =
  (MiscPottier.string_of_list ", " (fun x -> x) vars ^
   (if vars = [] then "" else ";"))


let print_table n =
  let f s (case, exit) =
    Printf.sprintf "%s%scase %d: exit %d;\n" s (n_spaces n) case exit
  in
  List.fold_left f ""


let rec print_body n = function
  | Cminor.St_skip -> ""
  | Cminor.St_assign (id, e) ->
      Printf.sprintf "%s%s = %s;\n" (n_spaces n) id (print_expression e)
  | Cminor.St_store (q, e1, e2) ->
      Printf.sprintf "%s%s[%s] = %s;\n"
        (n_spaces n)
        (Memory.string_of_quantity q)
        (print_expression e1)
        (print_expression e2)
  | Cminor.St_call (None, f, args, sg) ->
      Printf.sprintf "%s%s(%s) : %s;\n"
        (n_spaces n)
        (print_expression f)
        (print_args args)
        (print_sig sg)
  | Cminor.St_call (Some id, f, args, sg) ->
      Printf.sprintf "%s%s = %s(%s) : %s;\n"
        (n_spaces n)
        id
        (print_expression f)
        (print_args args)
        (print_sig sg)
  | Cminor.St_tailcall (f, args, sg) ->
      Printf.sprintf "%stailcall %s(%s) : %s;\n"
        (n_spaces n)
        (print_expression f)
        (print_args args)
        (print_sig sg)
  | Cminor.St_seq (s1, s2) -> (print_body n s1) ^ (print_body n s2)
  | Cminor.St_ifthenelse (e, s1, s2) ->
      Printf.sprintf "%sif (%s) {\n%s%s}\n%selse {\n%s%s}\n"
        (n_spaces n)
        (print_expression e)
        (print_body (n+2) s1)
        (n_spaces n)
        (n_spaces n)
        (print_body (n+2) s2)
        (n_spaces n)
  | Cminor.St_loop s ->
      Printf.sprintf "%sloop {\n%s%s}\n"
        (n_spaces n)
        (print_body (n+2) s)
        (n_spaces n)
  | Cminor.St_block s ->
      Printf.sprintf "%sblock {\n%s%s}\n"
        (n_spaces n)
        (print_body (n+2) s)
        (n_spaces n)
  | Cminor.St_exit i ->
      Printf.sprintf "%sexit %d;\n" (n_spaces n) i
  | Cminor.St_switch (e, tbl, dflt) ->
      Printf.sprintf "%sswitch (%s) {\n%s%sdefault: exit %d;\n%s}\n"
        (n_spaces n)
        (print_expression e)
        (print_table ( n+2) tbl)
        (n_spaces (n+2))
        dflt
        (n_spaces n)
  | Cminor.St_return None -> Printf.sprintf "%sreturn;\n" (n_spaces n)
  | Cminor.St_return (Some e) ->
      Printf.sprintf "%sreturn %s;\n" (n_spaces n) (print_expression e)
  | Cminor.St_label (lbl, s) ->
      Printf.sprintf "%s%s:\n%s" (n_spaces n) lbl (print_body n s)
  | Cminor.St_goto lbl ->
      Printf.sprintf "%sgoto %s;\n" (n_spaces n) lbl
  | Cminor.St_cost (lbl, s) ->
      Printf.sprintf "%s%s:\n%s"
        (n_spaces n) lbl (print_body n s)

let print_internal f_name f_def =
  Printf.sprintf "\"%s\" (%s) : %s {\n\n  stack %d;\n\n  vars: %s\n  pointers: %s\n\n%s}\n\n\n"
    f_name
    (print_args (List.map (fun id -> Cminor.Id id) f_def.Cminor.f_params))
    (print_sig f_def.Cminor.f_sig)
    f_def.Cminor.f_stacksize
    (print_locals f_def.Cminor.f_vars)
    (print_locals f_def.Cminor.f_ptrs)
    (print_body 2 f_def.Cminor.f_body)


let print_external f_name f_def =
  Printf.sprintf "extern \"%s\" : %s\n\n\n"
    f_name
    (print_sig f_def.ef_sig)


let print_funct (f_name, f_def) = match f_def with
  | Cminor.F_int f_def -> print_internal f_name f_def
  | Cminor.F_ext f_def -> print_external f_name f_def

let print_functs = List.fold_left (fun s f -> s ^ (print_funct f)) ""

let print_program p =
  Printf.sprintf "\n%s\n\n%s"
    (print_vars p.Cminor.vars)
    (print_functs p.Cminor.functs)

let string_of_statement s = match s with
    Cminor.St_skip -> "skip"
  | Cminor.St_assign(_,_) -> "assign"
  | Cminor.St_store(_,_,_) -> "store"
  | Cminor.St_call(_,_,_,_) -> "call"
  | Cminor.St_tailcall(_,_,_) -> "tailcall"
  | Cminor.St_seq(_,_) -> "seq"
  | Cminor.St_ifthenelse(_,_,_) -> "ifthenelse"
  | Cminor.St_loop(_) -> "loop"
  | Cminor.St_block(_) -> "block"
  | Cminor.St_exit(_) -> "exit"
  | Cminor.St_switch(_,_,_) -> "switch"
  | Cminor.St_return(_) -> "return"
  | Cminor.St_label(_,_) -> "label"
  | Cminor.St_goto(_) -> "goto"
  | Cminor.St_cost(_,_) -> "cost"