about summary refs log tree commit diff
path: root/src/comp/middle/trans_vec.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/comp/middle/trans_vec.rs')
-rw-r--r--src/comp/middle/trans_vec.rs60
1 files changed, 30 insertions, 30 deletions
diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs
index 48143461a31..08279f07b8b 100644
--- a/src/comp/middle/trans_vec.rs
+++ b/src/comp/middle/trans_vec.rs
@@ -12,26 +12,25 @@ import trans::{call_memmove, trans_shared_malloc, llsize_of, type_of_or_i8,
 import trans_build::*;
 import trans_common::*;
 
-fn get_fill(bcx: &@block_ctxt, vptrptr: ValueRef) -> ValueRef {
+fn get_fill(bcx: @block_ctxt, vptrptr: ValueRef) -> ValueRef {
     Load(bcx, GEPi(bcx, Load(bcx, vptrptr), [0, abi::vec_elt_fill as int]))
 }
-fn get_alloc(bcx: &@block_ctxt, vptrptr: ValueRef) -> ValueRef {
+fn get_alloc(bcx: @block_ctxt, vptrptr: ValueRef) -> ValueRef {
     Load(bcx, GEPi(bcx, Load(bcx, vptrptr), [0, abi::vec_elt_alloc as int]))
 }
-fn get_dataptr(bcx: &@block_ctxt, vptrptr: ValueRef, unit_ty: TypeRef) ->
+fn get_dataptr(bcx: @block_ctxt, vptrptr: ValueRef, unit_ty: TypeRef) ->
    ValueRef {
     let ptr = GEPi(bcx, Load(bcx, vptrptr), [0, abi::vec_elt_elems as int]);
     PointerCast(bcx, ptr, T_ptr(unit_ty))
 }
 
-fn pointer_add(bcx: &@block_ctxt, ptr: ValueRef, bytes: ValueRef) ->
-   ValueRef {
+fn pointer_add(bcx: @block_ctxt, ptr: ValueRef, bytes: ValueRef) -> ValueRef {
     let old_ty = val_ty(ptr);
     let bptr = PointerCast(bcx, ptr, T_ptr(T_i8()));
     ret PointerCast(bcx, InBoundsGEP(bcx, bptr, [bytes]), old_ty);
 }
 
-fn alloc_raw(bcx: &@block_ctxt, fill: ValueRef, alloc: ValueRef) -> result {
+fn alloc_raw(bcx: @block_ctxt, fill: ValueRef, alloc: ValueRef) -> result {
     let llvecty = T_opaque_vec();
     let vecsize = Add(bcx, alloc, llsize_of(llvecty));
     let {bcx: bcx, val: vecptr} =
@@ -50,7 +49,7 @@ type alloc_result =
      llunitsz: ValueRef,
      llunitty: TypeRef};
 
-fn alloc(bcx: &@block_ctxt, vec_ty: &ty::t, elts: uint) -> alloc_result {
+fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint) -> alloc_result {
     let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
     let llunitty = type_of_or_i8(bcx, unit_ty);
     let llvecty = T_vec(llunitty);
@@ -62,7 +61,8 @@ fn alloc(bcx: &@block_ctxt, vec_ty: &ty::t, elts: uint) -> alloc_result {
     let vptr = PointerCast(bcx, vptr, T_ptr(llvecty));
 
     let r = alloc_ty(bcx, vec_ty);
-    let vptrptr = r.val; bcx = r.bcx;
+    let vptrptr = r.val;
+    bcx = r.bcx;
 
     Store(bcx, vptr, vptrptr);
     add_clean_temp(bcx, vptrptr, vec_ty);
@@ -73,7 +73,7 @@ fn alloc(bcx: &@block_ctxt, vec_ty: &ty::t, elts: uint) -> alloc_result {
          llunitty: llunitty};
 }
 
-fn duplicate(bcx: &@block_ctxt, vptrptr: ValueRef) -> @block_ctxt {
+fn duplicate(bcx: @block_ctxt, vptrptr: ValueRef) -> @block_ctxt {
     let fill = get_fill(bcx, vptrptr);
     let vptr = Load(bcx, vptrptr);
     let size = Add(bcx, fill, llsize_of(T_opaque_vec()));
@@ -85,7 +85,7 @@ fn duplicate(bcx: &@block_ctxt, vptrptr: ValueRef) -> @block_ctxt {
     Store(bcx, newptr, vptrptr);
     ret bcx;
 }
-fn make_drop_glue(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t) ->
+fn make_drop_glue(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t) ->
    @block_ctxt {
     let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
     let vptr = Load(bcx, vptrptr);
@@ -102,7 +102,7 @@ fn make_drop_glue(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t) ->
     ret next_cx;
 }
 
-fn trans_vec(bcx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
+fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id) ->
    result {
     let vec_ty = node_id_type(bcx_ccx(bcx), id);
     let {bcx: bcx,
@@ -127,7 +127,7 @@ fn trans_vec(bcx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
     }
     ret rslt(bcx, vptr);
 }
-fn trans_str(bcx: &@block_ctxt, s: str) -> result {
+fn trans_str(bcx: @block_ctxt, s: str) -> result {
     let veclen = std::str::byte_len(s) + 1u; // +1 for \0
     let {bcx: bcx, val: sptr, _} =
         alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen);
@@ -140,7 +140,7 @@ fn trans_str(bcx: &@block_ctxt, s: str) -> result {
     ret rslt(bcx, sptr);
 }
 
-fn trans_append(cx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
+fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
                 rhsptr: ValueRef) -> result {
     // Cast to opaque interior vector types if necessary.
     let unit_ty = ty::sequence_element_type(bcx_tcx(cx), vec_ty);
@@ -179,7 +179,7 @@ fn trans_append(cx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
     let bcx =
         iter_vec_raw(bcx, rhsptr, vec_ty, rfill,
                      // We have to increment by the dynamically-computed size.
-                     {|&bcx, addr, _ty|
+                     {|bcx, addr, _ty|
                          let write_ptr = Load(bcx, write_ptr_ptr);
                          let bcx =
                              copy_val(bcx, INIT, write_ptr,
@@ -193,8 +193,8 @@ fn trans_append(cx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
     ret rslt(bcx, C_nil());
 }
 
-fn trans_append_literal(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
-                        vals: &[@ast::expr]) -> @block_ctxt {
+fn trans_append_literal(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
+                        vals: [@ast::expr]) -> @block_ctxt {
     let elt_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
     let ti = none;
     let {bcx: bcx, val: td} =
@@ -214,9 +214,8 @@ fn trans_append_literal(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
     ret bcx;
 }
 
-fn trans_add(bcx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
-             rhsptr: ValueRef)
-   -> result {
+fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
+             rhsptr: ValueRef) -> result {
     let strings =
         alt ty::struct(bcx_tcx(bcx), vec_ty) {
           ty::ty_str. { true }
@@ -239,15 +238,16 @@ fn trans_add(bcx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
     let write_ptr_ptr =
         do_spill_noroot(bcx, get_dataptr(bcx, new_vec_ptr_ptr, llunitty));
     let copy_fn =
-        bind fn (bcx: &@block_ctxt, addr: ValueRef, _ty: ty::t,
+        bind fn (bcx: @block_ctxt, addr: ValueRef, _ty: ty::t,
                  write_ptr_ptr: ValueRef, unit_ty: ty::t, llunitsz: ValueRef)
                 -> @block_ctxt {
                  let write_ptr = Load(bcx, write_ptr_ptr);
                  let bcx =
                      copy_val(bcx, INIT, write_ptr,
                               load_if_immediate(bcx, addr, unit_ty), unit_ty);
-                 let incr = ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) ?
-                     llunitsz : C_int(1);
+                 let incr =
+                     ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) ?
+                         llunitsz : C_int(1);
                  Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]),
                        write_ptr_ptr);
                  ret bcx;
@@ -258,12 +258,12 @@ fn trans_add(bcx: &@block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
     ret rslt(bcx, new_vec_ptr_ptr);
 }
 
-type val_and_ty_fn = fn(&@block_ctxt, ValueRef, ty::t) -> result;
+type val_and_ty_fn = fn(@block_ctxt, ValueRef, ty::t) -> result;
 
-type iter_vec_block = block(&@block_ctxt, ValueRef, ty::t) -> @block_ctxt;
+type iter_vec_block = block(@block_ctxt, ValueRef, ty::t) -> @block_ctxt;
 
-fn iter_vec_raw(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
-                fill: ValueRef, f: &iter_vec_block) -> @block_ctxt {
+fn iter_vec_raw(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
+                fill: ValueRef, f: iter_vec_block) -> @block_ctxt {
     let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
     let llunitty = type_of_or_i8(bcx, unit_ty);
     let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty);
@@ -289,14 +289,14 @@ fn iter_vec_raw(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
         if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) {
             unit_sz
         } else { C_int(1) };
-    AddIncomingToPhi(data_ptr, [InBoundsGEP(body_cx, data_ptr,
-                                            [increment])], [body_cx.llbb]);
+    AddIncomingToPhi(data_ptr, [InBoundsGEP(body_cx, data_ptr, [increment])],
+                     [body_cx.llbb]);
     Br(body_cx, header_cx.llbb);
     ret next_cx;
 }
 
-fn iter_vec(bcx: &@block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
-            f: &iter_vec_block) -> @block_ctxt {
+fn iter_vec(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t,
+            f: iter_vec_block) -> @block_ctxt {
     vptrptr = PointerCast(bcx, vptrptr, T_ptr(T_ptr(T_opaque_vec())));
     ret iter_vec_raw(bcx, vptrptr, vec_ty, get_fill(bcx, vptrptr), f);
 }