1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
import core::{str, option};
import std::math::{max, min};
import std::map::hashmap;
import option::{some};
import syntax::ast;
import ast::{ty, pat};
import syntax::codemap::{span};
import syntax::visit;
import syntax::print;
type flag = hashmap<str, ()>;
fn def_eq(a: ast::def_id, b: ast::def_id) -> bool {
ret a.crate == b.crate && a.node == b.node;
}
fn hash_def(d: ast::def_id) -> uint {
let h = 5381u;
h = (h << 5u) + h ^ (d.crate as uint);
h = (h << 5u) + h ^ (d.node as uint);
ret h;
}
fn new_def_hash<copy V>() -> std::map::hashmap<ast::def_id, V> {
let hasher: std::map::hashfn<ast::def_id> = hash_def;
let eqer: std::map::eqfn<ast::def_id> = def_eq;
ret std::map::mk_hashmap::<ast::def_id, V>(hasher, eqer);
}
fn field_expr(f: ast::field) -> @ast::expr { ret f.node.expr; }
fn field_exprs(fields: [ast::field]) -> [@ast::expr] {
let es = [];
for f: ast::field in fields { es += [f.node.expr]; }
ret es;
}
fn log_expr(e: ast::expr) { log print::pprust::expr_to_str(@e); }
fn log_expr_err(e: ast::expr) { log_err print::pprust::expr_to_str(@e); }
fn log_ty_err(t: @ty) { log_err print::pprust::ty_to_str(t); }
fn log_pat_err(p: @pat) { log_err print::pprust::pat_to_str(p); }
fn log_block(b: ast::blk) { log print::pprust::block_to_str(b); }
fn log_block_err(b: ast::blk) { log_err print::pprust::block_to_str(b); }
fn log_item_err(i: @ast::item) { log_err print::pprust::item_to_str(i); }
fn log_fn(f: ast::_fn, name: ast::ident, params: [ast::ty_param]) {
log print::pprust::fun_to_str(f, name, params);
}
fn log_fn_err(f: ast::_fn, name: ast::ident, params: [ast::ty_param]) {
log_err print::pprust::fun_to_str(f, name, params);
}
fn log_stmt(st: ast::stmt) { log print::pprust::stmt_to_str(st); }
fn log_stmt_err(st: ast::stmt) { log_err print::pprust::stmt_to_str(st); }
fn has_nonlocal_exits(b: ast::blk) -> bool {
let has_exits = @mutable false;
fn visit_expr(flag: @mutable bool, e: @ast::expr) {
alt e.node {
ast::expr_break. { *flag = true; }
ast::expr_cont. { *flag = true; }
_ { }
}
}
let v =
visit::mk_simple_visitor(@{visit_expr: bind visit_expr(has_exits, _)
with *visit::default_simple_visitor()});
visit::visit_block(b, (), v);
ret *has_exits;
}
fn local_rhs_span(l: @ast::local, def: span) -> span {
alt l.node.init { some(i) { ret i.expr.span; } _ { ret def; } }
}
fn is_main_name(path: [ast::ident]) -> bool {
str::eq(option::get(vec::last(path)), "main")
}
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
//
|
