From bca45720f7a364175aaefc6d4e9b6665fb8bf8ab Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 30 Jun 2011 17:29:54 -0700 Subject: [PATCH] Remove the environment concept from front::eval This is the old method of conditional compilation. It is going away. Issue #489 --- src/comp/driver/rustc.rs | 36 +++++++++++---------- src/comp/front/eval.rs | 67 ++++++++++++++++------------------------ src/comp/front/parser.rs | 23 +++----------- 3 files changed, 51 insertions(+), 75 deletions(-) diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index 55dcc35a637..97e7585f0d7 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -6,6 +6,7 @@ import front::parser; import front::token; import front::eval; import front::ast; +import front::attr; import middle::trans; import middle::resolve; import middle::ty; @@ -35,8 +36,8 @@ import back::link::output_type; tag pp_mode { ppm_normal; ppm_typed; ppm_identified; } -fn default_environment(session::session sess, str argv0, str input) -> - eval::env { +fn default_configuration(session::session sess, str argv0, str input) -> + ast::crate_cfg { auto libc = alt (sess.get_targ_cfg().os) { case (session::os_win32) { "msvcrt.dll" } @@ -44,13 +45,16 @@ fn default_environment(session::session sess, str argv0, str input) -> case (session::os_linux) { "libc.so.6" } case (_) { "libc.so" } }; + + auto mk = attr::mk_name_value_item; + ret [ // Target bindings. - tup("target_os", eval::val_str(std::os::target_os())), - tup("target_arch", eval::val_str("x86")), - tup("target_libc", eval::val_str(libc)), + mk("target_os", std::os::target_os()), + mk("target_arch", "x86"), + mk("target_libc", libc), // Build bindings. - tup("build_compiler", eval::val_str(argv0)), - tup("build_input", eval::val_str(input))]; + mk("build_compiler", argv0), + mk("build_input", input)]; } fn parse_input(session::session sess, parser::parser p, str input) -> @@ -73,10 +77,10 @@ fn time[T](bool do_it, str what, fn() -> T thunk) -> T { ret rv; } -fn compile_input(session::session sess, eval::env env, str input, +fn compile_input(session::session sess, ast::crate_cfg cfg, str input, str output) { auto time_passes = sess.get_opts().time_passes; - auto p = parser::new_parser(sess, env, input, 0u, 0); + auto p = parser::new_parser(sess, cfg, input, 0u, 0); auto crate = time(time_passes, "parsing", bind parse_input(sess, p, input)); if (sess.get_opts().output_type == link::output_type_none) { ret; } @@ -104,9 +108,9 @@ fn compile_input(session::session sess, eval::env env, str input, bind link::write::run_passes(sess, llmod, output)); } -fn pretty_print_input(session::session sess, eval::env env, str input, - pp_mode ppm) { - auto p = front::parser::new_parser(sess, env, input, 0u, 0); +fn pretty_print_input(session::session sess, ast::crate_cfg cfg, + str input, pp_mode ppm) { + auto p = front::parser::new_parser(sess, cfg, input, 0u, 0); auto crate = parse_input(sess, p, input); auto mode; alt (ppm) { @@ -337,7 +341,7 @@ fn main(vec[str] args) { } auto ifile = match.free.(0); let str saved_out_filename = ""; - auto env = default_environment(sess, binary, ifile); + auto cfg = default_configuration(sess, binary, ifile); auto pretty = option::map[str, pp_mode](bind parse_pretty(sess, _), @@ -345,7 +349,7 @@ fn main(vec[str] args) { auto ls = opt_present(match, "ls"); alt (pretty) { case (some[pp_mode](?ppm)) { - pretty_print_input(sess, env, ifile, ppm); + pretty_print_input(sess, cfg, ifile, ppm); ret; } case (none[pp_mode]) {/* continue */ } @@ -371,7 +375,7 @@ fn main(vec[str] args) { case (link::output_type_exe) { parts += ["o"]; } } auto ofile = str::connect(parts, "."); - compile_input(sess, env, ifile, ofile); + compile_input(sess, cfg, ifile, ofile); } case (some(?ofile)) { // FIXME: what about windows? This will create a foo.exe.o. @@ -386,7 +390,7 @@ fn main(vec[str] args) { } case (_) { temp_filename = ofile; } } - compile_input(sess, env, ifile, temp_filename); + compile_input(sess, cfg, ifile, temp_filename); } } diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs index 2dc76bd793b..df794992311 100644 --- a/src/comp/front/eval.rs +++ b/src/comp/front/eval.rs @@ -23,17 +23,14 @@ tag val { val_bool(bool); val_int(int); val_str(str); } tag eval_mode { mode_depend; mode_parse; } -type env = vec[tup(ident, val)]; - type ctx = @rec(parser p, eval_mode mode, mutable vec[str] deps, session::session sess, mutable uint chpos, - mutable int next_id); - -fn mk_env() -> env { ret []; } + mutable int next_id, + ast::crate_cfg cfg); fn val_is_bool(val v) -> bool { alt (v) { case (val_bool(_)) { true } case (_) { false } } @@ -59,13 +56,6 @@ fn val_as_str(val v) -> str { alt (v) { case (val_str(?s)) { s } case (_) { fail } } } -fn lookup(session::session sess, env e, span sp, ident i) -> val { - for (tup(ident, val) pair in e) { - if (str::eq(i, pair._0)) { ret pair._1; } - } - sess.span_fatal(sp, "unknown variable: " + i) -} - fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val { alt (lit.node) { case (ast::lit_bool(?b)) { val_bool(b) } @@ -75,18 +65,14 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val { } } -fn eval_expr(ctx cx, env e, @ast::expr x) -> val { +fn eval_expr(ctx cx, @ast::expr x) -> val { alt (x.node) { case (ast::expr_path(?pth)) { - if (vec::len[ident](pth.node.idents) == 1u && - vec::len[@ast::ty](pth.node.types) == 0u) { - ret lookup(cx.sess, e, x.span, pth.node.idents.(0)); - } cx.sess.span_fatal(x.span, "evaluating structured path-name"); } case (ast::expr_lit(?lit)) { ret eval_lit(cx, x.span, lit); } case (ast::expr_unary(?op, ?a)) { - auto av = eval_expr(cx, e, a); + auto av = eval_expr(cx, a); alt (op) { case (ast::not) { if (val_is_bool(av)) { ret val_bool(!val_as_bool(av)); } @@ -98,8 +84,8 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val { } } case (ast::expr_binary(?op, ?a, ?b)) { - auto av = eval_expr(cx, e, a); - auto bv = eval_expr(cx, e, b); + auto av = eval_expr(cx, a); + auto bv = eval_expr(cx, b); alt (op) { case (ast::add) { if (val_is_int(av) && val_is_int(bv)) { @@ -177,30 +163,30 @@ fn val_eq(session::session sess, span sp, val av, val bv) -> bool { } else { sess.span_fatal(sp, "bad types in comparison") } } -fn eval_crate_directives(ctx cx, env e, vec[@ast::crate_directive] cdirs, +fn eval_crate_directives(ctx cx, vec[@ast::crate_directive] cdirs, str prefix, &mutable vec[@ast::view_item] view_items, &mutable vec[@ast::item] items) { for (@ast::crate_directive sub_cdir in cdirs) { - eval_crate_directive(cx, e, sub_cdir, prefix, view_items, items); + eval_crate_directive(cx, sub_cdir, prefix, view_items, items); } } -fn eval_crate_directives_to_mod(ctx cx, env e, +fn eval_crate_directives_to_mod(ctx cx, vec[@ast::crate_directive] cdirs, str prefix) -> ast::_mod { let vec[@ast::view_item] view_items = []; let vec[@ast::item] items = []; - eval_crate_directives(cx, e, cdirs, prefix, view_items, items); + eval_crate_directives(cx, cdirs, prefix, view_items, items); ret rec(view_items=view_items, items=items); } -fn eval_crate_directive_block(ctx cx, env e, &ast::block blk, str prefix, +fn eval_crate_directive_block(ctx cx, &ast::block blk, str prefix, &mutable vec[@ast::view_item] view_items, &mutable vec[@ast::item] items) { for (@ast::stmt s in blk.node.stmts) { alt (s.node) { case (ast::stmt_crate_directive(?cdir)) { - eval_crate_directive(cx, e, cdir, prefix, view_items, items); + eval_crate_directive(cx, cdir, prefix, view_items, items); } case (_) { cx.sess.span_fatal(s.span, @@ -210,22 +196,22 @@ fn eval_crate_directive_block(ctx cx, env e, &ast::block blk, str prefix, } } -fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix, +fn eval_crate_directive_expr(ctx cx, @ast::expr x, str prefix, &mutable vec[@ast::view_item] view_items, &mutable vec[@ast::item] items) { alt (x.node) { case (ast::expr_if(?cond, ?thn, ?elopt)) { - auto cv = eval_expr(cx, e, cond); + auto cv = eval_expr(cx, cond); if (!val_is_bool(cv)) { cx.sess.span_fatal(x.span, "bad cond type in 'if'"); } if (val_as_bool(cv)) { - ret eval_crate_directive_block(cx, e, thn, prefix, view_items, + ret eval_crate_directive_block(cx, thn, prefix, view_items, items); } alt (elopt) { case (some(?els)) { - ret eval_crate_directive_expr(cx, e, els, prefix, + ret eval_crate_directive_expr(cx, els, prefix, view_items, items); } case (_) { @@ -235,19 +221,19 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix, } } case (ast::expr_alt(?v, ?arms)) { - auto vv = eval_expr(cx, e, v); + auto vv = eval_expr(cx, v); for (ast::arm arm in arms) { alt (arm.pat.node) { case (ast::pat_lit(?lit, _)) { auto pv = eval_lit(cx, arm.pat.span, lit); if (val_eq(cx.sess, arm.pat.span, vv, pv)) { - ret eval_crate_directive_block(cx, e, arm.block, + ret eval_crate_directive_block(cx, arm.block, prefix, view_items, items); } } case (ast::pat_wild(_)) { - ret eval_crate_directive_block(cx, e, arm.block, + ret eval_crate_directive_block(cx, arm.block, prefix, view_items, items); } @@ -260,24 +246,23 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix, cx.sess.span_fatal(x.span, "no cases matched in 'alt'"); } case (ast::expr_block(?block)) { - ret eval_crate_directive_block(cx, e, block, prefix, view_items, + ret eval_crate_directive_block(cx, block, prefix, view_items, items); } case (_) { cx.sess.span_fatal(x.span, "unsupported expr type"); } } } -fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix, +fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix, &mutable vec[@ast::view_item] view_items, &mutable vec[@ast::item] items) { alt (cdir.node) { case (ast::cdir_let(?id, ?x, ?cdirs)) { - auto v = eval_expr(cx, e, x); - auto e0 = [tup(id, v)] + e; - eval_crate_directives(cx, e0, cdirs, prefix, view_items, items); + auto v = eval_expr(cx, x); + eval_crate_directives(cx, cdirs, prefix, view_items, items); } case (ast::cdir_expr(?x)) { - eval_crate_directive_expr(cx, e, x, prefix, view_items, items); + eval_crate_directive_expr(cx, x, prefix, view_items, items); } case (ast::cdir_src_mod(?id, ?file_opt, ?attrs)) { auto file_path = id + ".rs"; @@ -292,7 +277,7 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix, }; if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; } auto p0 = - new_parser(cx.sess, e, full_path, cx.chpos, + new_parser(cx.sess, cx.cfg, full_path, cx.chpos, cx.next_id); auto inner_attrs = parse_inner_attrs_and_next(p0); auto mod_attrs = attrs + inner_attrs._0; @@ -315,7 +300,7 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix, } else { prefix + std::fs::path_sep() + path }; - auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path); + auto m0 = eval_crate_directives_to_mod(cx, cdirs, full_path); auto i = @rec(ident=id, attrs=attrs, id=cx.next_id, diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index e2f51cba6a5..0d86d5d949e 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -32,7 +32,6 @@ type parser = fn restrict(restriction) ; fn get_restriction() -> restriction ; fn get_file_type() -> file_type ; - fn get_env() -> eval::env ; fn get_cfg() -> ast::crate_cfg; fn get_session() -> session::session ; fn get_span() -> common::span ; @@ -50,10 +49,9 @@ type parser = fn next_id() -> ast::node_id ; }; -fn new_parser(session::session sess, eval::env env, +fn new_parser(session::session sess, ast::crate_cfg cfg, str path, uint pos, ast::node_id next_id) -> parser { obj stdio_parser(session::session sess, - eval::env env, ast::crate_cfg cfg, file_type ftype, mutable token::token tok, @@ -85,7 +83,6 @@ fn new_parser(session::session sess, eval::env env, fn get_hi_pos() -> uint { ret hi; } fn get_last_lo_pos() -> uint { ret last_lo; } fn get_file_type() -> file_type { ret ftype; } - fn get_env() -> eval::env { ret env; } fn get_cfg() -> ast::crate_cfg { ret cfg; } fn get_prec_table() -> vec[op_spec] { ret precs; } fn get_str(token::str_num i) -> str { @@ -106,17 +103,6 @@ fn new_parser(session::session sess, eval::env env, fn next_id() -> ast::node_id { ret next_id_var; } } - auto cfg = { - fn m(&tup(ast::ident, eval::val) item) -> @ast::meta_item { - auto name = item._0; - auto value = eval::val_as_str(item._1); - auto meta_item_ = ast::meta_name_value(name, value); - ret @rec(node=meta_item_, - span=rec(lo=0u,hi=0u)); - } - vec::map(m, env) - }; - auto ftype = SOURCE_FILE; if (str::ends_with(path, ".rc")) { ftype = CRATE_FILE; } auto srdr = io::file_reader(path); @@ -128,7 +114,7 @@ fn new_parser(session::session sess, eval::env env, lexer::consume_whitespace_and_comments(rdr); auto npos = rdr.get_chpos(); - ret stdio_parser(sess, env, cfg, ftype, lexer::next_token(rdr), + ret stdio_parser(sess, cfg, ftype, lexer::next_token(rdr), npos, npos, npos, UNRESTRICTED, rdr, prec_table(), next_id, bad_expr_word_table(), ext::syntax_expander_table()); @@ -2465,9 +2451,10 @@ fn parse_crate_from_crate_file(&parser p) -> @ast::crate { mutable deps=deps, sess=p.get_session(), mutable chpos=p.get_chpos(), - mutable next_id=p.next_id()); + mutable next_id=p.next_id(), + cfg = p.get_cfg()); auto m = - eval::eval_crate_directives_to_mod(cx, p.get_env(), cdirs, prefix); + eval::eval_crate_directives_to_mod(cx, cdirs, prefix); auto hi = p.get_hi_pos(); expect(p, token::EOF); ret @spanned(lo, hi, rec(directives=cdirs,