Removed trans_comm.rs from the compiler. Updating aio/sio to work with the new chan and port system, started on a networking module for the standard library.

4 files changed, 0 insertions, 356 deletions

diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index f077516bdf6..ea0a793780a 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -70,12 +70,6 @@ import syntax::print::pprust::path_to_str;
 
 import trans_common::*;
 
-import trans_comm::trans_port;
-import trans_comm::trans_chan;
-import trans_comm::trans_spawn;
-import trans_comm::trans_send;
-import trans_comm::trans_recv;
-
 import trans_objects::trans_anon_obj;
 import trans_objects::trans_obj;
 
@@ -5172,13 +5166,6 @@ fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) ->
       ast::expr_ret(ex) { ret trans_ret(cx, ex); }
       ast::expr_put(ex) { ret trans_put(cx, ex); }
       ast::expr_be(ex) { ret trans_be(cx, ex); }
-      ast::expr_port(_) { ret trans_port(cx, e.id); }
-      ast::expr_chan(ex) { ret trans_chan(cx, ex, e.id); }
-      ast::expr_send(lhs, rhs) { ret trans_send(cx, lhs, rhs, e.id); }
-      ast::expr_recv(lhs, rhs) { ret trans_recv(cx, lhs, rhs, e.id); }
-      ast::expr_spawn(dom, name, func, args) {
-        ret trans_spawn(cx, dom, name, func, args, e.id);
-      }
       ast::expr_anon_obj(anon_obj) {
         ret trans_anon_obj(cx, e.span, anon_obj, e.id);
       }
diff --git a/src/comp/middle/trans_comm.rs b/src/comp/middle/trans_comm.rs
deleted file mode 100644
index c0a4e15ed8b..00000000000
--- a/src/comp/middle/trans_comm.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-/**
-   Translation for various task and comm-related things.
-
-   Most of this will probably go away as we move more of this into
-   libraries.
-
-*/
-
-import std::str;
-import std::option;
-import option::none;
-import option::some;
-
-import lib::llvm::llvm;
-import lib::llvm::llvm::ValueRef;
-
-import util::ppaux::ty_to_str;
-import syntax::print::pprust::expr_to_str;
-import syntax::ast;
-import back::link::mangle_internal_name_by_path_and_seq;
-
-import trans_common::*;
-import trans::*;
-
-export trans_port;
-export trans_chan;
-export trans_spawn;
-export trans_send;
-export trans_recv;
-
-fn trans_port(cx: &@block_ctxt, id: ast::node_id) -> result {
-    let t = node_id_type(cx.fcx.lcx.ccx, id);
-    let unit_ty;
-    alt ty::struct(cx.fcx.lcx.ccx.tcx, t) {
-      ty::ty_port(t) { unit_ty = t; }
-      _ { cx.fcx.lcx.ccx.sess.bug("non-port type in trans_port"); }
-    }
-    let bcx = cx;
-    let unit_sz = size_of(bcx, unit_ty);
-    bcx = unit_sz.bcx;
-    let port_raw_val =
-        bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.new_port,
-                       ~[bcx.fcx.lltaskptr, unit_sz.val]);
-    let llty = type_of(cx.fcx.lcx.ccx, cx.sp, t);
-    let port_val = bcx.build.PointerCast(port_raw_val, llty);
-    add_clean_temp(bcx, port_val, t);
-    ret rslt(bcx, port_val);
-}
-
-fn trans_chan(cx: &@block_ctxt, e: &@ast::expr, id: ast::node_id) -> result {
-    let bcx = cx;
-    let prt = trans_expr(bcx, e);
-    bcx = prt.bcx;
-    let prt_val = bcx.build.PointerCast(prt.val, T_opaque_port_ptr());
-    let chan_raw_val =
-        bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.new_chan,
-                       ~[bcx.fcx.lltaskptr, prt_val]);
-    let chan_ty = node_id_type(bcx.fcx.lcx.ccx, id);
-    let chan_llty = type_of(bcx.fcx.lcx.ccx, e.span, chan_ty);
-    let chan_val = bcx.build.PointerCast(chan_raw_val, chan_llty);
-    add_clean_temp(bcx, chan_val, chan_ty);
-    ret rslt(bcx, chan_val);
-}
-
-fn trans_spawn(cx: &@block_ctxt, dom: &ast::spawn_dom, name: &option::t[str],
-               func: &@ast::expr, args: &[@ast::expr], id: ast::node_id) ->
-   result {
-    let bcx = cx;
-    // Make the task name
-
-    let tname =
-        alt name {
-          none. {
-            let argss = std::ivec::map(expr_to_str, args);
-            #fmt("%s(%s)", expr_to_str(func), str::connect(argss, ", "))
-          }
-          some(n) { n }
-        };
-    // Generate code
-    //
-    // This is a several step process. The following things need to happen
-    // (not necessarily in order):
-    //
-    // 1. Evaluate all the arguments to the spawnee.
-    //
-    // 2. Alloca a tuple that holds these arguments (they must be in reverse
-    // order, so that they match the expected stack layout for the spawnee)
-    //
-    // 3. Fill the tuple with the arguments we evaluated.
-    //
-    // 3.5. Generate a wrapper function that takes the tuple and unpacks it to
-    // call the real task.
-    //
-    // 4. Pass a pointer to the wrapper function and the argument tuple to
-    // upcall_start_task. In order to do this, we need to allocate another
-    // tuple that matches the arguments expected by rust_task::start.
-    //
-    // 5. Oh yeah, we have to create the task before we start it...
-
-    // But first, we'll create a task.
-
-    let lltname: ValueRef = C_str(bcx.fcx.lcx.ccx, tname);
-    let new_task =
-        bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.new_task,
-                       ~[bcx.fcx.lltaskptr, lltname]);
-
-    // Translate the arguments, remembering their types and where the values
-    // ended up.
-
-    let arg_tys: [ty::t] = ~[];
-    let arg_vals: [ValueRef] = ~[];
-    for e: @ast::expr in args {
-        let e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, e);
-        let arg = trans_expr(bcx, e);
-
-        arg = deep_copy(arg.bcx, arg.val, e_ty, new_task);
-
-        bcx = arg.bcx;
-
-        arg_vals += ~[arg.val];
-        arg_tys += ~[e_ty];
-    }
-    // Make the tuple.
-
-    let args_ty = ty::mk_tup(cx.fcx.lcx.ccx.tcx, arg_tys);
-    // Allocate and fill the tuple.
-
-    let llargs = alloc_ty(bcx, args_ty);
-    let i = 0u;
-    for v: ValueRef in arg_vals {
-        let target = bcx.build.GEP(llargs.val, ~[C_int(0), C_int(i as int)]);
-
-        bcx.build.Store(v, target);
-        i += 1u;
-    }
-
-    // Generate the wrapper function
-    let wrapper = mk_spawn_wrapper(bcx, func, args_ty);
-    bcx = wrapper.bcx;
-    let llfnptr_i = bcx.build.PointerCast(wrapper.val, T_int());
-
-    // And start the task
-    let llargs_i = bcx.build.PointerCast(llargs.val, T_int());
-    let args_size = size_of(bcx, args_ty).val;
-    bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.start_task,
-                   ~[bcx.fcx.lltaskptr, new_task, llfnptr_i, llargs_i,
-                     args_size]);
-    let task_ty = node_id_type(bcx.fcx.lcx.ccx, id);
-    add_clean_temp(bcx, new_task, task_ty);
-    ret rslt(bcx, new_task);
-}
-
-fn mk_spawn_wrapper(cx: &@block_ctxt, func: &@ast::expr, args_ty: &ty::t) ->
-   result {
-    let llmod = cx.fcx.lcx.ccx.llmod;
-    let wrapper_fn_type =
-        type_of_fn(cx.fcx.lcx.ccx, cx.sp, ast::proto_fn,
-                   ~[{mode: ty::mo_alias(false), ty: args_ty}], ty::idx_nil,
-                   0u);
-    // TODO: construct a name based on tname
-
-    let wrap_name: str =
-        mangle_internal_name_by_path_and_seq(cx.fcx.lcx.ccx, cx.fcx.lcx.path,
-                                             "spawn_wrapper");
-    let llfndecl = decl_cdecl_fn(llmod, wrap_name, wrapper_fn_type);
-    let fcx = new_fn_ctxt(cx.fcx.lcx, cx.sp, llfndecl);
-    let fbcx = new_top_block_ctxt(fcx);
-    // 3u to skip the three implicit args
-
-    let arg: ValueRef = llvm::LLVMGetParam(fcx.llfn, 3u);
-    let child_args: [ValueRef] =
-        ~[llvm::LLVMGetParam(fcx.llfn, 0u), llvm::LLVMGetParam(fcx.llfn, 1u),
-          llvm::LLVMGetParam(fcx.llfn, 2u)];
-    // unpack the arguments
-
-    alt ty::struct(fcx.lcx.ccx.tcx, args_ty) {
-      ty::ty_tup(elts) {
-        let i = 0;
-        for elt in elts {
-            let src = fbcx.build.GEP(arg, ~[C_int(0), C_int(i)]);
-            i += 1;
-            let child_arg = fbcx.build.Load(src);
-            child_args += ~[child_arg];
-        }
-      }
-    }
-    // Find the function
-
-    let fnptr = trans_lval(fbcx, func).res;
-    fbcx = fnptr.bcx;
-    let llfnptr = fbcx.build.GEP(fnptr.val, ~[C_int(0), C_int(0)]);
-    let llfn = fbcx.build.Load(llfnptr);
-    fbcx.build.FastCall(llfn, child_args);
-    fbcx.build.RetVoid();
-    finish_fn(fcx, fbcx.llbb);
-    // TODO: make sure we clean up everything we need to.
-
-    ret rslt(cx, llfndecl);
-}
-
-fn trans_send(cx: &@block_ctxt, lhs: &@ast::expr, rhs: &@ast::expr,
-              id: ast::node_id) -> result {
-    let bcx = cx;
-    let chn = trans_expr(bcx, lhs);
-    bcx = chn.bcx;
-    let data = trans_lval(bcx, rhs);
-    bcx = data.res.bcx;
-    let chan_ty = node_id_type(cx.fcx.lcx.ccx, id);
-    let unit_ty;
-    alt ty::struct(cx.fcx.lcx.ccx.tcx, chan_ty) {
-      ty::ty_chan(t) { unit_ty = t; }
-      _ { bcx.fcx.lcx.ccx.sess.bug("non-chan type in trans_send"); }
-    }
-    let data_alloc = alloc_ty(bcx, unit_ty);
-    bcx = data_alloc.bcx;
-    let data_tmp = move_val_if_temp(bcx, INIT, data_alloc.val, data, unit_ty);
-    bcx = data_tmp.bcx;
-    let llchanval = bcx.build.PointerCast(chn.val, T_opaque_chan_ptr());
-    let lldataptr = bcx.build.PointerCast(data_alloc.val, T_ptr(T_i8()));
-    bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.send,
-                   ~[bcx.fcx.lltaskptr, llchanval, lldataptr]);
-
-    // Deinit the stuff we sent.
-    bcx = zero_alloca(bcx, data_alloc.val, unit_ty).bcx;
-
-    ret rslt(bcx, chn.val);
-}
-
-fn trans_recv(cx: &@block_ctxt, lhs: &@ast::expr, rhs: &@ast::expr,
-              id: ast::node_id) -> result {
-    let bcx = cx;
-    // FIXME: calculate copy init-ness in typestate.
-
-    let unit_ty = node_id_type(cx.fcx.lcx.ccx, id);
-    let tmp_alloc = alloc_ty(bcx, unit_ty);
-    bcx = tmp_alloc.bcx;
-
-    let prt = trans_expr(bcx, lhs);
-    bcx = prt.bcx;
-    let lldataptr = bcx.build.PointerCast(tmp_alloc.val,
-                                          T_ptr(T_ptr(T_i8())));
-    let llportptr = bcx.build.PointerCast(prt.val, T_opaque_port_ptr());
-    bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.recv,
-                   ~[bcx.fcx.lltaskptr, lldataptr, llportptr]);
-
-    let tmp = load_if_immediate(bcx, tmp_alloc.val, unit_ty);
-
-    let data = trans_lval(bcx, rhs);
-    assert (data.is_mem);
-    bcx = data.res.bcx;
-
-    let tmp_lval = lval_val(bcx, tmp);
-
-    let recv_res =
-        move_val(bcx, DROP_EXISTING, data.res.val, tmp_lval, unit_ty);
-
-    ret rslt(recv_res.bcx, recv_res.val);
-}
-
-// Does a deep copy of a value. This is needed for passing arguments to child
-// tasks, and for sending things through channels. There are probably some
-// uniqueness optimizations and things we can do here for tasks in the same
-// domain.
-fn deep_copy(bcx: &@block_ctxt, v: ValueRef, t: ty::t, target_task: ValueRef)
-   -> result {
-    // TODO: make sure all paths add any reference counting that they need to.
-
-    // TODO: Teach deep copy to understand everything else it needs to.
-
-    let tcx = bcx.fcx.lcx.ccx.tcx;
-    if ty::type_is_scalar(tcx, t) {
-        ret rslt(bcx, v);
-    } else if (ty::type_is_str(tcx, t)) {
-        ret rslt(bcx,
-                 bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.dup_str,
-                                ~[bcx.fcx.lltaskptr, target_task, v]));
-    } else if (ty::type_is_chan(tcx, t)) {
-        // If this is a channel, we need to clone it.
-        let chan_ptr = bcx.build.PointerCast(v, T_opaque_chan_ptr());
-
-        let chan_raw_val =
-            bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.clone_chan,
-                           ~[bcx.fcx.lltaskptr, target_task, chan_ptr]);
-
-        // Cast back to the type the context was expecting.
-        let chan_val = bcx.build.PointerCast(chan_raw_val, val_ty(v));
-
-        ret rslt(bcx, chan_val);
-    } else if (ty::type_is_structural(tcx, t)) {
-        fn inner_deep_copy(bcx: &@block_ctxt, v: ValueRef, t: ty::t) ->
-           result {
-            log_err "Unimplemented type for deep_copy.";
-            fail;
-        }
-
-        ret iter_structural_ty(bcx, v, t, inner_deep_copy);
-    } else {
-        bcx.fcx.lcx.ccx.sess.bug("unexpected type in " + "trans::deep_copy: "
-                                     + ty_to_str(tcx, t));
-    }
-}
-
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index a0505f870b4..e701b40f939 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -1,4 +1,3 @@
-
 // -*- rust -*-
 
 #[link(name = "rustc",
@@ -18,7 +17,6 @@ mod middle {
     mod trans_common;
     mod trans;
     mod trans_alt;
-    mod trans_comm;
     mod trans_dps;
     mod trans_objects;
     mod trans_vec;
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 93cdf617a63..e807fda20f9 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -577,16 +577,6 @@ fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
         alt t { ast::ty_fn(_, _, out, _, _) { hi = out.span.hi; } }
     } else if (eat_word(p, "obj")) {
         t = parse_ty_obj(p, hi);
-    } else if (eat_word(p, "port")) {
-        expect(p, token::LBRACKET);
-        t = ast::ty_port(parse_ty(p, false));
-        hi = p.get_hi_pos();
-        expect(p, token::RBRACKET);
-    } else if (eat_word(p, "chan")) {
-        expect(p, token::LBRACKET);
-        t = ast::ty_chan(parse_ty(p, false));
-        hi = p.get_hi_pos();
-        expect(p, token::RBRACKET);
     } else if (eat_word(p, "mutable")) {
         p.warn("ignoring deprecated 'mutable' type constructor");
         let typ = parse_ty(p, false);
@@ -990,30 +980,11 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
         }
     } else if (eat_word(p, "be")) {
         let e = parse_expr(p);
-
-
         // FIXME: Is this the right place for this check?
         if /*check*/ast::is_call_expr(e) {
             hi = e.span.hi;
             ex = ast::expr_be(e);
         } else { p.fatal("Non-call expression in tail call"); }
-    } else if (eat_word(p, "port")) {
-        let ty = @spanned(lo, hi, ast::ty_infer);
-        if token::LBRACKET == p.peek() {
-            expect(p, token::LBRACKET);
-            ty = parse_ty(p, false);
-            expect(p, token::RBRACKET);
-        }
-        expect(p, token::LPAREN);
-        expect(p, token::RPAREN);
-        hi = p.get_hi_pos();
-        ex = ast::expr_port(ty);
-    } else if (eat_word(p, "chan")) {
-        expect(p, token::LPAREN);
-        let e = parse_expr(p);
-        hi = e.span.hi;
-        expect(p, token::RPAREN);
-        ex = ast::expr_chan(e);
     } else if (eat_word(p, "copy")) {
         let e = parse_expr(p);
         ex = ast::expr_copy(e);
@@ -1271,16 +1242,6 @@ fn parse_assign_expr(p: &parser) -> @ast::expr {
         let rhs = parse_expr(p);
         ret mk_expr(p, lo, rhs.span.hi, ast::expr_move(lhs, rhs));
       }
-      token::SEND. {
-        p.bump();
-        let rhs = parse_expr(p);
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_send(lhs, rhs));
-      }
-      token::RECV. {
-        p.bump();
-        let rhs = parse_expr(p);
-        ret mk_expr(p, lo, rhs.span.hi, ast::expr_recv(lhs, rhs));
-      }
       token::DARROW. {
         p.bump();
         let rhs = parse_expr(p);