path: root/src/comp/util/common.rs

import std.Map;
import std.Map.hashmap;
import std.UInt;
import std.Int;
import std.Vec;
import std.Option.none;
import front.ast;
import util.typestate_ann.ts_ann;

import middle.fold;
import middle.fold.respan;

import std.IO.stdout;
import std.IO.str_writer;
import std.IO.string_writer;
import pretty.pprust.print_block;
import pretty.pprust.print_expr;
import pretty.pprust.print_decl;
import pretty.pprust.print_fn;
import pretty.pp.mkstate;

type filename = str;
type span = rec(uint lo, uint hi);
type spanned[T] = rec(T node, span span);
type flag = hashmap[str, ()];

tag ty_mach {
    ty_i8;
    ty_i16;
    ty_i32;
    ty_i64;

    ty_u8;
    ty_u16;
    ty_u32;
    ty_u64;

    ty_f32;
    ty_f64;
}

fn ty_mach_to_str(ty_mach tm) -> str {
    alt (tm) {
        case (ty_u8) { ret "u8"; }
        case (ty_u16) { ret "u16"; }
        case (ty_u32) { ret "u32"; }
        case (ty_u64) { ret "u64"; }

        case (ty_i8) { ret "i8"; }
        case (ty_i16) { ret "i16"; }
        case (ty_i32) { ret "i32"; }
        case (ty_i64) { ret "i64"; }

        case (ty_f32) { ret "f32"; }
        case (ty_f64) { ret "f64"; }
    }
}

fn new_str_hash[V]() -> std.Map.hashmap[str,V] {
    let std.Map.hashfn[str] hasher = std.Str.hash;
    let std.Map.eqfn[str] eqer = std.Str.eq;
    ret std.Map.mk_hashmap[str,V](hasher, eqer);
}

fn def_eq(&ast.def_id a, &ast.def_id b) -> bool {
    ret a._0 == b._0 && a._1 == b._1;
}

fn hash_def(&ast.def_id d) -> uint {
    auto h = 5381u;
    h = ((h << 5u) + h) ^ (d._0 as uint);
    h = ((h << 5u) + h) ^ (d._1 as uint);
    ret h;
}

fn new_def_hash[V]() -> std.Map.hashmap[ast.def_id,V] {
    let std.Map.hashfn[ast.def_id] hasher = hash_def;
    let std.Map.eqfn[ast.def_id] eqer = def_eq;
    ret std.Map.mk_hashmap[ast.def_id,V](hasher, eqer);
}

fn new_int_hash[V]() -> std.Map.hashmap[int,V] {
    fn hash_int(&int x) -> uint { ret x as uint; }
    fn eq_int(&int a, &int b) -> bool { ret a == b; }
    auto hasher = hash_int;
    auto eqer = eq_int;
    ret std.Map.mk_hashmap[int,V](hasher, eqer);
}

fn new_uint_hash[V]() -> std.Map.hashmap[uint,V] {
    fn hash_uint(&uint x) -> uint { ret x; }
    fn eq_uint(&uint a, &uint b) -> bool { ret a == b; }
    auto hasher = hash_uint;
    auto eqer = eq_uint;
    ret std.Map.mk_hashmap[uint,V](hasher, eqer);
}

fn istr(int i) -> str {
    ret Int.to_str(i, 10u);
}

fn uistr(uint i) -> str {
    ret UInt.to_str(i, 10u);
}

fn elt_expr(&ast.elt e) -> @ast.expr { ret e.expr; }

fn elt_exprs(&vec[ast.elt] elts) -> vec[@ast.expr] {
    auto f = elt_expr;
    ret Vec.map[ast.elt, @ast.expr](f, elts);
}

fn field_expr(&ast.field f) -> @ast.expr { ret f.expr; }

fn field_exprs(vec[ast.field] fields) -> vec [@ast.expr] {
    auto f = field_expr;
    ret Vec.map[ast.field, @ast.expr](f, fields);
}

fn plain_ann(&ast.ann old, middle.ty.ctxt tcx) -> ast.ann {
    ret ast.ann_type(ast.ann_tag(old), middle.ty.mk_nil(tcx),
                   none[vec[middle.ty.t]], none[@ts_ann]);
}

fn expr_to_str(&@ast.expr e) -> str {
  let str_writer s = string_writer();
  auto out_ = mkstate(s.get_writer(), 80u);
  auto out = @rec(s=out_,
                  comments=none[vec[front.lexer.cmnt]],
                  mutable cur_cmnt=0u);
  print_expr(out, e);
  ret s.get_str();
}

fn log_expr(&ast.expr e) -> () {
    log(expr_to_str(@e));
}

fn log_expr_err(&ast.expr e) -> () {
    log_err(expr_to_str(@e));
}

fn block_to_str(&ast.block b) -> str {
  let str_writer s = string_writer();
  auto out_ = mkstate(s.get_writer(), 80u);
  auto out = @rec(s=out_,
                  comments=none[vec[front.lexer.cmnt]],
                  mutable cur_cmnt=0u);

  print_block(out, b);
  ret s.get_str();
}

fn log_block(&ast.block b) -> () {
    log(block_to_str(b));
}

fn log_block_err(&ast.block b) -> () {
    log_err(block_to_str(b));
}

fn log_ann(&ast.ann a) -> () {
    alt (a) {
        case (ast.ann_none(_)) {
            log("ann_none");
        }
        case (ast.ann_type(_,_,_,_)) {
            log("ann_type");
        }
    }
}

fn fun_to_str(&ast._fn f, str name, vec[ast.ty_param] params) -> str {
 let str_writer s = string_writer();
  auto out_ = mkstate(s.get_writer(), 80u);
  auto out = @rec(s=out_,
                  comments=none[vec[front.lexer.cmnt]],
                  mutable cur_cmnt=0u);

  print_fn(out, f.decl, name, params);
  ret s.get_str();
}

fn log_fn(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
    log(fun_to_str(f, name, params));
}

fn log_fn_err(&ast._fn f, str name, vec[ast.ty_param] params) -> () {
    log_err(fun_to_str(f, name, params));
}

fn stmt_to_str(&ast.stmt st) -> str {
  let str_writer s = string_writer();
  auto out_ = mkstate(s.get_writer(), 80u);
  auto out = @rec(s=out_,
                  comments=none[vec[front.lexer.cmnt]],
                  mutable cur_cmnt=0u);
  alt (st.node) {
    case (ast.stmt_decl(?decl,_)) {
      print_decl(out, decl);
    }
    case (ast.stmt_expr(?ex,_)) {
      print_expr(out, ex);
    }
    case (_) { /* do nothing */ }
  }
  ret s.get_str();
}

fn log_stmt(&ast.stmt st) -> () {
    log(stmt_to_str(st));
}

fn log_stmt_err(&ast.stmt st) -> () {
    log_err(stmt_to_str(st));
}

fn decl_lhs(@ast.decl d) -> ast.def_id {
    alt (d.node) {
        case (ast.decl_local(?l)) {
            ret l.id;
        }
        case (ast.decl_item(?an_item)) {
            alt (an_item.node) {
                case (ast.item_const(_,_,_,?d,_)) {
                    ret d;
                }
                case (ast.item_fn(_,_,_,?d,_)) {
                    ret d;
                }
                case (ast.item_mod(_,_,?d)) {
                    ret d;
                }
                case (ast.item_native_mod(_,_,?d)) {
                    ret d;
                }
                case (ast.item_ty(_,_,_,?d,_)) {
                    ret d;
                }
                case (ast.item_tag(_,_,_,?d,_)) {
                    ret d;
                }
                case (ast.item_obj(_,_,_,?d,_)) {
                    ret d.ctor; /* This doesn't really make sense */
                }
            }
        } 
    }
}

fn has_nonlocal_exits(&ast.block b) -> bool {
    /* overkill, but just passing around a mutable bool doesn't seem
       to work in rustboot */
    auto has_exits = new_str_hash[()]();

   fn set_break(&flag f, &span sp, &ast.ann a) -> @ast.expr {
        f.insert("foo", ());
        ret @respan(sp, ast.expr_break(a));
    }
    fn set_cont(&flag f, &span sp, &ast.ann a) -> @ast.expr {
        f.insert("foo", ());
        ret @respan(sp, ast.expr_cont(a));
    }
    fn check_b(&flag f) -> bool {
        ret (f.size() == 0u);
    }

    auto fld0 = fold.new_identity_fold[flag]();

    fld0 = @rec(fold_expr_break = bind set_break(_,_,_),
                fold_expr_cont  = bind set_cont(_,_,_),
                keep_going      = bind check_b(_) with *fld0);
    fold.fold_block[flag](has_exits, fld0, b);

    ret (has_exits.size() > 0u);
}
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//