136 lines
4.2 KiB
Rust
136 lines
4.2 KiB
Rust
import std::vec;
|
|
import std::option;
|
|
import syntax::ast;
|
|
import syntax::fold;
|
|
import attr;
|
|
|
|
export strip_unconfigured_items;
|
|
|
|
// Support conditional compilation by transforming the AST, stripping out
|
|
// any items that do not belong in the current configuration
|
|
fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
|
|
let cfg = crate.node.config;
|
|
|
|
let precursor =
|
|
{fold_mod: bind fold_mod(cfg, _, _),
|
|
fold_block: bind fold_block(cfg, _, _),
|
|
fold_native_mod: bind fold_native_mod(cfg, _, _)
|
|
with *fold::default_ast_fold()};
|
|
|
|
let fold = fold::make_fold(precursor);
|
|
let res = @fold.fold_crate(*crate);
|
|
// FIXME: This is necessary to break a circular reference
|
|
fold::dummy_out(fold);
|
|
ret res;
|
|
}
|
|
|
|
fn filter_item(cfg: &ast::crate_cfg, item: &@ast::item) ->
|
|
option::t<@ast::item> {
|
|
if item_in_cfg(cfg, item) { option::some(item) } else { option::none }
|
|
}
|
|
|
|
fn fold_mod(cfg: &ast::crate_cfg, m: &ast::_mod, fld: fold::ast_fold) ->
|
|
ast::_mod {
|
|
let filter = bind filter_item(cfg, _);
|
|
let filtered_items = vec::filter_map(filter, m.items);
|
|
ret {view_items: vec::map(fld.fold_view_item, m.view_items),
|
|
items: vec::map(fld.fold_item, filtered_items)};
|
|
}
|
|
|
|
fn filter_native_item(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
|
|
option::t<@ast::native_item> {
|
|
if native_item_in_cfg(cfg, item) {
|
|
option::some(item)
|
|
} else { option::none }
|
|
}
|
|
|
|
fn fold_native_mod(cfg: &ast::crate_cfg, nm: &ast::native_mod,
|
|
fld: fold::ast_fold) -> ast::native_mod {
|
|
let filter = bind filter_native_item(cfg, _);
|
|
let filtered_items = vec::filter_map(filter, nm.items);
|
|
ret {native_name: nm.native_name,
|
|
abi: nm.abi,
|
|
view_items: vec::map(fld.fold_view_item, nm.view_items),
|
|
items: filtered_items};
|
|
}
|
|
|
|
fn filter_stmt(cfg: &ast::crate_cfg, stmt: &@ast::stmt) ->
|
|
option::t<@ast::stmt> {
|
|
alt stmt.node {
|
|
ast::stmt_decl(decl, _) {
|
|
alt decl.node {
|
|
ast::decl_item(item) {
|
|
if item_in_cfg(cfg, item) {
|
|
option::some(stmt)
|
|
} else { option::none }
|
|
}
|
|
_ { option::some(stmt) }
|
|
}
|
|
}
|
|
_ { option::some(stmt) }
|
|
}
|
|
}
|
|
|
|
fn fold_block(cfg: &ast::crate_cfg, b: &ast::blk_, fld: fold::ast_fold) ->
|
|
ast::blk_ {
|
|
let filter = bind filter_stmt(cfg, _);
|
|
let filtered_stmts = vec::filter_map(filter, b.stmts);
|
|
ret {stmts: vec::map(fld.fold_stmt, filtered_stmts),
|
|
expr: option::map(fld.fold_expr, b.expr),
|
|
id: b.id, rules: b.rules};
|
|
}
|
|
|
|
fn item_in_cfg(cfg: &ast::crate_cfg, item: &@ast::item) -> bool {
|
|
ret in_cfg(cfg, item.attrs);
|
|
}
|
|
|
|
fn native_item_in_cfg(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
|
|
bool {
|
|
ret in_cfg(cfg, item.attrs);
|
|
}
|
|
|
|
// Determine if an item should be translated in the current crate
|
|
// configuration based on the item's attributes
|
|
fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
|
|
|
|
// The "cfg" attributes on the item
|
|
let item_cfg_attrs = attr::find_attrs_by_name(attrs, ~"cfg");
|
|
let item_has_cfg_attrs = vec::len(item_cfg_attrs) > 0u;
|
|
if !item_has_cfg_attrs { ret true; }
|
|
|
|
// Pull the inner meta_items from the #[cfg(meta_item, ...)] attributes,
|
|
// so we can match against them. This is the list of configurations for
|
|
// which the item is valid
|
|
let item_cfg_metas =
|
|
{
|
|
fn extract_metas(inner_items: &[@ast::meta_item],
|
|
cfg_item: &@ast::meta_item) ->
|
|
[@ast::meta_item] {
|
|
alt cfg_item.node {
|
|
ast::meta_list(name, items) {
|
|
assert (name == ~"cfg");
|
|
inner_items + items
|
|
}
|
|
_ { inner_items }
|
|
}
|
|
}
|
|
let cfg_metas = attr::attr_metas(item_cfg_attrs);
|
|
vec::foldl(extract_metas, [], cfg_metas)
|
|
};
|
|
|
|
for cfg_mi: @ast::meta_item in item_cfg_metas {
|
|
if attr::contains(cfg, cfg_mi) { ret true; }
|
|
}
|
|
|
|
ret false;
|
|
}
|
|
|
|
|
|
// Local Variables:
|
|
// 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:
|