There's no need for the restrictions of a closure with the above methods.
static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum
fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
- bytes.as_imm_buf(|b, len| {
- unsafe {
- let mut outsz : size_t = 0;
- let res =
- rustrt::tdefl_compress_mem_to_heap(b as *c_void,
- len as size_t,
- &mut outsz,
- flags);
- assert!(res as int != 0);
+ unsafe {
+ let mut outsz : size_t = 0;
+ let res = rustrt::tdefl_compress_mem_to_heap(bytes.as_ptr() as *c_void,
+ bytes.len() as size_t,
+ &mut outsz,
+ flags);
+ assert!(res as int != 0);
let out = vec::raw::from_buf_raw(res as *u8,
outsz as uint);
- libc::free(res);
- out
- }
- })
+ libc::free(res);
+ out
+ }
}
pub fn deflate_bytes(bytes: &[u8]) -> ~[u8] {
}
fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
- bytes.as_imm_buf(|b, len| {
- unsafe {
- let mut outsz : size_t = 0;
- let res =
- rustrt::tinfl_decompress_mem_to_heap(b as *c_void,
- len as size_t,
- &mut outsz,
- flags);
- assert!(res as int != 0);
- let out = vec::raw::from_buf_raw(res as *u8,
- outsz as uint);
- libc::free(res);
- out
- }
- })
+ unsafe {
+ let mut outsz : size_t = 0;
+ let res = rustrt::tinfl_decompress_mem_to_heap(bytes.as_ptr() as *c_void,
+ bytes.len() as size_t,
+ &mut outsz,
+ flags);
+ assert!(res as int != 0);
+ let out = vec::raw::from_buf_raw(res as *u8,
+ outsz as uint);
+ libc::free(res);
+ out
+ }
}
pub fn inflate_bytes(bytes: &[u8]) -> ~[u8] {
add(*arg);
}
- llvm_args.as_imm_buf(|p, len| {
- llvm::LLVMRustSetLLVMOptions(len as c_int, p);
- })
+ llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int, llvm_args.as_ptr());
}
unsafe fn populate_llvm_passes(fpm: lib::llvm::PassManagerRef,
let mut t = s.to_utf16();
// Null terminate before passing on.
t.push(0u16);
- t.as_imm_buf(|buf, _len| f(buf))
+ f(t.as_ptr())
}
#[link_name = "kernel32"]
return Err(format!("failure in BeginUpdateResourceW: {}", os::last_os_error()));
}
- let ok = manifest.as_imm_buf(|p, len| {
- UpdateResourceW(hUpdate,
- MAKEINTRESOURCEW(24), // RT_MANIFEST
- MAKEINTRESOURCEW(1), // CREATEPROCESS_MANIFEST_RESOURCE_ID
- 0, // LANG_NEUTRAL, SUBLANG_NEUTRAL
- p as LPCVOID,
- len as u32)
- });
+ let ok = UpdateResourceW(hUpdate,
+ MAKEINTRESOURCEW(24), // RT_MANIFEST
+ MAKEINTRESOURCEW(1), // CREATEPROCESS_MANIFEST_RESOURCE_ID
+ 0, // LANG_NEUTRAL, SUBLANG_NEUTRAL
+ manifest.as_ptr() as LPCVOID,
+ manifest.len() as u32);
if ok == FALSE {
return Err(format!("failure in UpdateResourceW: {}", os::last_os_error()));
}
(rust_main, args)
};
- let result = args.as_imm_buf(|buf, len| {
- llvm::LLVMBuildCall(bld, start_fn, buf, len as c_uint, noname())
- });
+ let result = llvm::LLVMBuildCall(bld, start_fn,
+ args.as_ptr(), args.len() as c_uint,
+ noname());
llvm::LLVMBuildRet(bld, result);
}
let min = llvm::LLVMConstInt(t, lo, signed);
let max = llvm::LLVMConstInt(t, hi, signed);
- [min, max].as_imm_buf(|ptr, len| {
- llvm::LLVMSetMetadata(value, lib::llvm::MD_range as c_uint,
- llvm::LLVMMDNodeInContext(self.ccx.llcx,
- ptr, len as c_uint));
- })
+ let v = [min, max];
+
+ llvm::LLVMSetMetadata(value, lib::llvm::MD_range as c_uint,
+ llvm::LLVMMDNodeInContext(self.ccx.llcx,
+ v.as_ptr(), v.len() as c_uint));
}
value
pub fn C_struct(elts: &[ValueRef], packed: bool) -> ValueRef {
unsafe {
- elts.as_imm_buf(|ptr, len| {
- llvm::LLVMConstStructInContext(base::task_llcx(), ptr, len as c_uint, packed as Bool)
- })
+
+ llvm::LLVMConstStructInContext(base::task_llcx(),
+ elts.as_ptr(), elts.len() as c_uint,
+ packed as Bool)
}
}
pub fn C_named_struct(T: Type, elts: &[ValueRef]) -> ValueRef {
unsafe {
- elts.as_imm_buf(|ptr, len| {
- llvm::LLVMConstNamedStruct(T.to_ref(), ptr, len as c_uint)
- })
+ llvm::LLVMConstNamedStruct(T.to_ref(), elts.as_ptr(), elts.len() as c_uint)
}
}
pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint])
-> ValueRef {
unsafe {
- let r = us.as_imm_buf(|p, len| {
- llvm::LLVMConstExtractValue(v, p, len as c_uint)
- });
+ let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
debug!("const_get_elt(v={}, us={:?}, r={})",
cx.tn.val_to_str(v), us, cx.tn.val_to_str(r));
}
// Perform the call itself
- let llrust_ret_val = llrust_args.as_imm_buf(|ptr, len| {
- debug!("calling llrustfn = {}", ccx.tn.val_to_str(llrustfn));
- llvm::LLVMBuildCall(builder, llrustfn, ptr,
- len as c_uint, noname())
- });
+ debug!("calling llrustfn = {}", ccx.tn.val_to_str(llrustfn));
+ let llrust_ret_val = llvm::LLVMBuildCall(builder, llrustfn, llrust_args.as_ptr(),
+ llrust_args.len() as c_uint, noname());
// Get the return value where the foreign fn expects it.
let llforeign_ret_ty = match tys.fn_ty.ret_ty.cast {
},
flags: 0,
stdio_count: stdio.len() as libc::c_int,
- stdio: stdio.as_imm_buf(|p, _| p),
+ stdio: stdio.as_ptr(),
uid: 0,
gid: 0,
};
c_args.push(s.with_ref(|p| p));
}
c_args.push(ptr::null());
- c_args.as_imm_buf(|buf, _| f(buf))
+ f(c_args.as_ptr())
}
/// Converts the environment to the env array expected by libuv
c_envp.push(s.with_ref(|p| p));
}
c_envp.push(ptr::null());
- c_envp.as_imm_buf(|buf, _| f(buf))
+ f(c_envp.as_ptr())
}
impl HomingIO for Process {
}
unsafe fn to_c_str_unchecked(&self) -> CString {
- self.as_imm_buf(|self_buf, self_len| {
- let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
- if buf.is_null() {
- fail!("failed to allocate memory!");
- }
+ let self_len = self.len();
+ let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
+ if buf.is_null() {
+ fail!("failed to allocate memory!");
+ }
- ptr::copy_memory(buf, self_buf, self_len);
- *ptr::mut_offset(buf, self_len as int) = 0;
+ ptr::copy_memory(buf, self.as_ptr(), self_len);
+ *ptr::mut_offset(buf, self_len as int) = 0;
- CString::new(buf as *libc::c_char, true)
- })
+ CString::new(buf as *libc::c_char, true)
}
fn with_c_str<T>(&self, f: |*libc::c_char| -> T) -> T {
#[cfg(windows)] static eintr: int = 0; // doesn't matter
#[cfg(not(windows))] static eintr: int = libc::EINTR as int;
- let (data, origamt) = data.as_imm_buf(|data, amt| (data, amt));
- let mut data = data;
+ let origamt = data.len();
+ let mut data = data.as_ptr();
let mut amt = origamt;
while amt > 0 {
let mut ret;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use cast;
use io;
use libc::{pid_t, c_void, c_int};
use libc;
use ptr;
use rt::rtio;
use super::file;
+#[cfg(windows)]
+use cast;
use p = io::process;
// Finally, make sure we add a null pointer.
ptrs.push(ptr::null());
- ptrs.as_imm_buf(|buf, _| cb(buf))
+ cb(ptrs.as_ptr())
}
#[cfg(unix)]
let mut ptrs = tmps.map(|tmp| tmp.with_ref(|buf| buf));
ptrs.push(ptr::null());
- ptrs.as_imm_buf(|buf, _| unsafe { cb(cast::transmute(buf)) })
+ cb(ptrs.as_ptr() as *c_void)
}
_ => cb(ptr::null())
}
blk.push(0);
- blk.as_imm_buf(|p, _len| unsafe { cb(cast::transmute(p)) })
+ cb(blk.as_mut_ptr() as *mut c_void)
}
_ => cb(ptr::mut_null())
}
let mut t = s.to_utf16();
// Null terminate before passing on.
t.push(0u16);
- t.as_imm_buf(|buf, _len| f(buf))
+ f(t.as_ptr())
}
}
"there".with_c_str(|p1| {
"thing".with_c_str(|p2| {
let v = ~[p0, p1, p2, null()];
- v.as_imm_buf(|vp, len| {
- assert_eq!(unsafe { buf_len(vp) }, 3u);
- assert_eq!(len, 4u);
- })
+ unsafe {
+ assert_eq!(buf_len(v.as_ptr()), 3u);
+ }
})
})
})
one, two, three
];
- arr.as_imm_buf(|arr_ptr, arr_len| {
- let mut ctr = 0;
- let mut iteration_count = 0;
- array_each_with_len(arr_ptr, arr_len, |e| {
- let actual = str::raw::from_c_str(e);
- let expected = expected_arr[ctr].with_ref(|buf| {
- str::raw::from_c_str(buf)
- });
- debug!(
- "test_ptr_array_each_with_len e: {}, a: {}",
- expected, actual);
- assert_eq!(actual, expected);
- ctr += 1;
- iteration_count += 1;
+ let mut ctr = 0;
+ let mut iteration_count = 0;
+ array_each_with_len(arr.as_ptr(), arr.len(), |e| {
+ let actual = str::raw::from_c_str(e);
+ let expected = expected_arr[ctr].with_ref(|buf| {
+ str::raw::from_c_str(buf)
+ });
+ debug!(
+ "test_ptr_array_each_with_len e: {}, a: {}",
+ expected, actual);
+ assert_eq!(actual, expected);
+ ctr += 1;
+ iteration_count += 1;
});
- assert_eq!(iteration_count, 3u);
- })
+ assert_eq!(iteration_count, 3u);
}
}
one, two, three
];
- arr.as_imm_buf(|arr_ptr, _| {
- let mut ctr = 0;
- let mut iteration_count = 0;
- array_each(arr_ptr, |e| {
- let actual = str::raw::from_c_str(e);
- let expected = expected_arr[ctr].with_ref(|buf| {
- str::raw::from_c_str(buf)
- });
- debug!(
- "test_ptr_array_each e: {}, a: {}",
- expected, actual);
- assert_eq!(actual, expected);
- ctr += 1;
- iteration_count += 1;
+ let arr_ptr = arr.as_ptr();
+ let mut ctr = 0;
+ let mut iteration_count = 0;
+ array_each(arr_ptr, |e| {
+ let actual = str::raw::from_c_str(e);
+ let expected = expected_arr[ctr].with_ref(|buf| {
+ str::raw::from_c_str(buf)
+ });
+ debug!(
+ "test_ptr_array_each e: {}, a: {}",
+ expected, actual);
+ assert_eq!(actual, expected);
+ ctr += 1;
+ iteration_count += 1;
});
- assert_eq!(iteration_count, 3);
- })
+ assert_eq!(iteration_count, 3);
}
}
#[inline]
fn as_imm_buf<T>(&self, f: |*u8, uint| -> T) -> T {
let v: &[u8] = unsafe { cast::transmute(*self) };
- v.as_imm_buf(f)
+ f(v.as_ptr(), v.len())
}
}
/// Returns the length of a vector
#[inline]
fn len(&self) -> uint {
- self.as_imm_buf(|_p, len| len)
+ self.repr().len
}
}
/// Returns the length of a vector
#[inline]
fn len(&self) -> uint {
- self.as_imm_buf(|_p, len| len)
+ self.repr().len
}
}
/// of a vector and return the results.
fn map<U>(&self, |t: &T| -> U) -> ~[U];
- /**
- * Work with the buffer of a vector.
- *
- * Allows for unsafe manipulation of vector contents, which is useful for
- * foreign interop.
- */
- fn as_imm_buf<U>(&self, f: |*T, uint| -> U) -> U;
-
/**
* Returns a mutable reference to the first element in this slice
* and adjusts the slice in place so that it no longer contains
fn slice(&self, start: uint, end: uint) -> &'a [T] {
assert!(start <= end);
assert!(end <= self.len());
- self.as_imm_buf(|p, _len| {
- unsafe {
- cast::transmute(Slice {
- data: ptr::offset(p, start as int),
+ unsafe {
+ cast::transmute(Slice {
+ data: self.as_ptr().offset(start as int),
len: (end - start)
})
- }
- })
+ }
}
#[inline]
self.iter().map(f).collect()
}
- #[inline]
- fn as_imm_buf<U>(&self, f: |*T, uint| -> U) -> U {
- let s = self.repr();
- f(s.data, s.len)
- }
-
fn shift_ref(&mut self) -> &'a T {
unsafe {
let s: &mut Slice<T> = cast::transmute(self);
#[inline]
unsafe fn copy_memory(self, src: &[T]) {
self.as_mut_buf(|p_dst, len_dst| {
- src.as_imm_buf(|p_src, len_src| {
- assert!(len_dst >= len_src)
- ptr::copy_nonoverlapping_memory(p_dst, p_src, len_src)
- })
+ let len_src = src.len();
+ assert!(len_dst >= len_src);
+ ptr::copy_nonoverlapping_memory(p_dst, src.as_ptr(), len_src)
})
}
dst.reserve_additional(src.len());
unsafe {
dst.as_mut_buf(|p_dst, len_dst| {
- src.as_imm_buf(|p_src, len_src| {
- ptr::copy_memory(p_dst.offset(len_dst as int), p_src, len_src)
- })
+ ptr::copy_memory(p_dst.offset(len_dst as int), src.as_ptr(), src.len())
});
dst.set_len(old_len + src.len());
}
}
}
- #[test]
- #[should_fail]
- fn test_as_imm_buf_fail() {
- let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
- v.as_imm_buf(|_buf, _i| {
- fail!()
- })
- }
-
#[test]
#[should_fail]
fn test_as_mut_buf_fail() {
// huge).
let x = ~[1u,2u,3u];
- x.as_imm_buf(|p, _len| {
- let base = p as uint;
- let idx = base / mem::size_of::<uint>();
- error!("ov1 base = 0x{:x}", base);
- error!("ov1 idx = 0x{:x}", idx);
- error!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
- error!("ov1 idx * sizeof::<uint>() = 0x{:x}",
- idx * mem::size_of::<uint>());
- // This should fail.
- error!("ov1 0x{:x}", x[idx]);
- })
+ let base = x.as_ptr() as uint;
+ let idx = base / mem::size_of::<uint>();
+ error!("ov1 base = 0x{:x}", base);
+ error!("ov1 idx = 0x{:x}", idx);
+ error!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
+ error!("ov1 idx * sizeof::<uint>() = 0x{:x}",
+ idx * mem::size_of::<uint>());
+
+ // This should fail.
+ error!("ov1 0x{:x}", x[idx]);
}
projects / rust.git / commitdiff