/// Add a line to history
pub unsafe fn add_history(line: &str) -> bool {
- do str::as_c_str(line) |buf| {
+ do line.as_c_str |buf| {
rustrt::linenoiseHistoryAdd(buf) == 1 as c_int
}
}
/// Save line history to a file
pub unsafe fn save_history(file: &str) -> bool {
- do str::as_c_str(file) |buf| {
+ do file.as_c_str |buf| {
rustrt::linenoiseHistorySave(buf) == 1 as c_int
}
}
/// Load line history from a file
pub unsafe fn load_history(file: &str) -> bool {
- do str::as_c_str(file) |buf| {
+ do file.as_c_str |buf| {
rustrt::linenoiseHistoryLoad(buf) == 1 as c_int
}
}
/// Print out a prompt and then wait for input and return it
pub unsafe fn read(prompt: &str) -> Option<~str> {
- do str::as_c_str(prompt) |buf| {
+ do prompt.as_c_str |buf| {
let line = rustrt::linenoise(buf);
if line.is_null() { None }
unsafe {
do cb(str::raw::from_c_str(line)) |suggestion| {
- do str::as_c_str(suggestion) |buf| {
+ do suggestion.as_c_str |buf| {
rustrt::linenoiseAddCompletion(completions, buf);
}
}
OptLevel: c_int,
EnableSegmentedStacks: bool) {
unsafe {
- do str::as_c_str(Triple) |Triple| {
- do str::as_c_str(Feature) |Feature| {
- do str::as_c_str(Output) |Output| {
+ do Triple.as_c_str |Triple| {
+ do Feature.as_c_str |Feature| {
+ do Output.as_c_str |Output| {
let result = llvm::LLVMRustWriteOutputFile(
PM,
M,
output_type_bitcode => {
if opts.optimize != session::No {
let filename = output.with_filetype("no-opt.bc");
- str::as_c_str(filename.to_str(), |buf| {
- llvm::LLVMWriteBitcodeToFile(llmod, buf)
- });
+ do filename.to_str().as_c_str |buf| {
+ llvm::LLVMWriteBitcodeToFile(llmod, buf);
+ }
}
}
_ => {
let filename = output.with_filetype("bc");
- str::as_c_str(filename.to_str(), |buf| {
- llvm::LLVMWriteBitcodeToFile(llmod, buf)
- });
+ do filename.to_str().as_c_str |buf| {
+ llvm::LLVMWriteBitcodeToFile(llmod, buf);
+ }
}
}
}
// Always output the bitcode file with --save-temps
let filename = output.with_filetype("opt.bc");
- str::as_c_str(filename.to_str(), |buf| {
+ do filename.to_str().as_c_str |buf| {
llvm::LLVMWriteBitcodeToFile(llmod, buf)
- });
+ };
// Save the assembly file if -S is used
if output_type == output_type_assembly {
WriteOutputFile(
if output_type == output_type_llvm_assembly {
// Given options "-S --emit-llvm": output LLVM assembly
- str::as_c_str(output.to_str(), |buf_o| {
- llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o)});
+ do output.to_str().as_c_str |buf_o| {
+ llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o);
+ }
} else {
// If only a bitcode file is asked for by using the
// '--emit-llvm' flag, then output it here
- str::as_c_str(output.to_str(),
- |buf| llvm::LLVMWriteBitcodeToFile(llmod, buf) );
+ do output.to_str().as_c_str |buf| {
+ llvm::LLVMWriteBitcodeToFile(llmod, buf);
+ }
}
llvm::LLVMDisposeModule(llmod);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::str;
use std::io;
use driver::session::{OptLevel, No, Less, Aggressive};
}
pub fn create_pass(name:&str) -> Option<PassRef> {
- do str::as_c_str(name) |s| {
+ do name.as_c_str |s| {
unsafe {
let p = llvm::LLVMCreatePass(s);
if p.is_null() {
use std::hashmap::HashMap;
use std::libc::{c_uint, c_ushort};
use std::option;
-use std::str;
use middle::trans::type_::Type;
}
pub fn mk_target_data(string_rep: &str) -> TargetData {
- let lltd =
- str::as_c_str(string_rep, |buf| unsafe {
- llvm::LLVMCreateTargetData(buf)
- });
+ let lltd = do string_rep.as_c_str |buf| {
+ unsafe { llvm::LLVMCreateTargetData(buf) }
+ };
TargetData {
lltd: lltd,
fn get_metadata_section(os: os,
filename: &Path) -> Option<@~[u8]> {
unsafe {
- let mb = str::as_c_str(filename.to_str(), |buf| {
+ let mb = do filename.to_str().as_c_str |buf| {
llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
- });
+ };
if mb as int == 0 { return option::None::<@~[u8]>; }
let of = match mk_object_file(mb) {
option::Some(of) => of,
use middle::trans::type_::Type;
-use std::str;
use syntax::ast;
// Take an inline assembly expression and splat it out via LLVM
ast::asm_intel => lib::llvm::AD_Intel
};
- let r = do str::as_c_str(ia.asm) |a| {
- do str::as_c_str(constraints) |c| {
+ let r = do ia.asm.as_c_str |a| {
+ do constraints.as_c_str |c| {
InlineAsmCall(bcx, a, c, inputs, output, ia.volatile, ia.alignstack, dialect)
}
};
use std::int;
use std::io;
use std::libc::c_uint;
-use std::str;
use std::uint;
use std::vec;
use std::local_data;
// Structural comparison: a rather involved form of glue.
pub fn maybe_name_value(cx: &CrateContext, v: ValueRef, s: &str) {
if cx.sess.opts.save_temps {
- let _: () = str::as_c_str(s, |buf| {
+ do s.as_c_str |buf| {
unsafe {
llvm::LLVMSetValueName(v, buf)
}
- });
+ }
}
}
pub fn mk_staticallocas_basic_block(llfn: ValueRef) -> BasicBlockRef {
unsafe {
let cx = task_llcx();
- str::as_c_str("static_allocas",
- |buf| llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf))
+ do "static_allocas".as_c_str | buf| {
+ llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf)
+ }
}
}
pub fn mk_return_basic_block(llfn: ValueRef) -> BasicBlockRef {
unsafe {
let cx = task_llcx();
- str::as_c_str("return",
- |buf| llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf))
+ do "return".as_c_str |buf| {
+ llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf)
+ }
}
}
};
decl_cdecl_fn(ccx.llmod, main_name, llfty)
};
- let llbb = str::as_c_str("top", |buf| {
+ let llbb = do "top".as_c_str |buf| {
unsafe {
llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)
}
- });
+ };
let bld = ccx.builder.B;
unsafe {
llvm::LLVMPositionBuilderAtEnd(bld, llbb);
exprt = m == ast::m_mutbl;
unsafe {
let llty = llvm::LLVMTypeOf(v);
- let g = str::as_c_str(s, |buf| {
+ let g = do s.as_c_str |buf| {
llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
- });
+ };
ccx.item_symbols.insert(i.id, s);
g
}
ast::foreign_item_static(*) => {
let typ = ty::node_id_to_type(ccx.tcx, ni.id);
let ident = token::ident_to_str(&ni.ident);
- let g = do str::as_c_str(ident) |buf| {
+ let g = do ident.as_c_str |buf| {
unsafe {
let ty = type_of(ccx, typ);
llvm::LLVMAddGlobal(ccx.llmod, ty.to_ref(), buf)
let s = mangle_exported_name(ccx, p, ty::mk_int()).to_managed();
let disr_val = vi[i].disr_val;
note_unique_llvm_symbol(ccx, s);
- let discrim_gvar = str::as_c_str(s, |buf| {
+ let discrim_gvar = do s.as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf)
}
- });
+ };
unsafe {
llvm::LLVMSetInitializer(discrim_gvar, C_int(ccx, disr_val));
llvm::LLVMSetGlobalConstant(discrim_gvar, True);
}
let gc_metadata_name = ~"_gc_module_metadata_" + llmod_id;
- let gc_metadata = do str::as_c_str(gc_metadata_name) |buf| {
+ let gc_metadata = do gc_metadata_name.as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(ccx.llmod, Type::i32().to_ref(), buf)
}
let sym_name = ~"_rust_crate_map_" + mapname;
let arrtype = Type::array(&int_type, n_subcrates as u64);
let maptype = Type::struct_([Type::i32(), Type::i8p(), int_type, arrtype], false);
- let map = str::as_c_str(sym_name, |buf| {
+ let map = do sym_name.as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(llmod, maptype.to_ref(), buf)
}
- });
+ };
lib::llvm::SetLinkage(map, lib::llvm::ExternalLinkage);
return map;
}
cdata.name,
cstore::get_crate_vers(cstore, i),
cstore::get_crate_hash(cstore, i));
- let cr = str::as_c_str(nm, |buf| {
+ let cr = do nm.as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf)
}
- });
+ };
subcrates.push(p2i(ccx, cr));
i += 1;
}
let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item);
let llmeta = C_bytes(encoder::encode_metadata(encode_parms, crate));
let llconst = C_struct([llmeta]);
- let mut llglobal = str::as_c_str("rust_metadata", |buf| {
+ let mut llglobal = do "rust_metadata".as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst).to_ref(), buf)
}
- });
+ };
unsafe {
llvm::LLVMSetInitializer(llglobal, llconst);
- str::as_c_str(cx.sess.targ_cfg.target_strs.meta_sect_name, |buf| {
+ do cx.sess.targ_cfg.target_strs.meta_sect_name.as_c_str |buf| {
llvm::LLVMSetSection(llglobal, buf)
- });
+ };
lib::llvm::SetLinkage(llglobal, lib::llvm::InternalLinkage);
let t_ptr_i8 = Type::i8p();
internal: bool)
-> ValueRef {
unsafe {
- let llglobal = do str::as_c_str(name) |buf| {
+ let llglobal = do name.as_c_str |buf| {
llvm::LLVMAddGlobal(ccx.llmod, val_ty(llval).to_ref(), buf)
};
llvm::LLVMSetInitializer(llglobal, llval);
use std::cast;
use std::hashmap::HashMap;
use std::libc::{c_uint, c_ulonglong, c_char};
-use std::str;
use std::vec;
use syntax::codemap::span;
if name.is_empty() {
llvm::LLVMBuildAlloca(self.llbuilder, ty.to_ref(), noname())
} else {
- str::as_c_str(
- name,
- |c| llvm::LLVMBuildAlloca(self.llbuilder, ty.to_ref(), c))
+ do name.as_c_str |c| {
+ llvm::LLVMBuildAlloca(self.llbuilder, ty.to_ref(), c)
+ }
}
}
}
let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
- let T: ValueRef = str::as_c_str("llvm.trap", |buf| {
+ let T: ValueRef = do "llvm.trap".as_c_str |buf| {
llvm::LLVMGetNamedFunction(M, buf)
- });
+ };
assert!((T as int != 0));
let args: &[ValueRef] = [];
self.count_insn("trap");
use middle::trans::type_::Type;
use std::libc::c_uint;
-use std::str;
use syntax::{ast, ast_util, ast_map};
pub fn const_lit(cx: &mut CrateContext, e: &ast::expr, lit: ast::lit)
ast::expr_vec(ref es, ast::m_imm) => {
let (cv, sz, llunitty) = const_vec(cx, e, *es);
let llty = val_ty(cv);
- let gv = do str::as_c_str("const") |name| {
+ let gv = do "const".as_c_str |name| {
llvm::LLVMAddGlobal(cx.llmod, llty.to_ref(), name)
};
llvm::LLVMSetInitializer(gv, cv);
use std::hash;
use std::hashmap::{HashMap, HashSet};
-use std::str;
use std::local_data;
use syntax::ast;
unsafe {
let llcx = llvm::LLVMContextCreate();
set_task_llcx(llcx);
- let llmod = str::as_c_str(name, |buf| {
- llvm::LLVMModuleCreateWithNameInContext(buf, llcx)
- });
+ let llmod = name.as_c_str(|buf| llvm::LLVMModuleCreateWithNameInContext(buf, llcx));
let data_layout: &str = sess.targ_cfg.target_strs.data_layout;
let targ_triple: &str = sess.targ_cfg.target_strs.target_triple;
- str::as_c_str(data_layout, |buf| llvm::LLVMSetDataLayout(llmod, buf));
- str::as_c_str(targ_triple, |buf| llvm::LLVMSetTarget(llmod, buf));
+ data_layout.as_c_str(|buf| llvm::LLVMSetDataLayout(llmod, buf));
+ targ_triple.as_c_str(|buf| llvm::LLVMSetTarget(llmod, buf));
let targ_cfg = sess.targ_cfg;
let td = mk_target_data(sess.targ_cfg.target_strs.data_layout);
use middle::trans::type_::Type;
-use std::str;
use syntax::ast;
use syntax::ast::ident;
use syntax::ast_map::path_mod;
ccx, modpath, "loglevel");
let global;
unsafe {
- global = str::as_c_str(s, |buf| {
+ global = do s.as_c_str |buf| {
llvm::LLVMAddGlobal(ccx.llmod, Type::i32().to_ref(), buf)
- });
+ };
llvm::LLVMSetGlobalConstant(global, False);
llvm::LLVMSetInitializer(global, C_null(Type::i32()));
lib::llvm::SetLinkage(global, lib::llvm::InternalLinkage);
use std::hashmap::HashMap;
use std::libc::{c_uint, c_ulonglong, c_longlong};
use std::ptr;
-use std::str::as_c_str;
use std::vec;
use syntax::codemap::span;
use syntax::{ast, codemap, ast_util, ast_map};
Some(_) => lexical_block_metadata(bcx)
};
- let var_metadata = do as_c_str(name) |name| {
+ let var_metadata = do name.as_c_str |name| {
unsafe {
llvm::LLVMDIBuilderCreateLocalVariable(
DIB(cx),
// XXX: This is wrong; it should work for multiple bindings.
let ident = path.idents.last();
let name: &str = cx.sess.str_of(*ident);
- let var_metadata = do as_c_str(name) |name| {
+ let var_metadata = do name.as_c_str |name| {
unsafe {
llvm::LLVMDIBuilderCreateLocalVariable(
DIB(cx),
};
let fn_metadata =
- do as_c_str(cx.sess.str_of(ident)) |name| {
- do as_c_str(cx.sess.str_of(ident)) |linkage| {
+ do cx.sess.str_of(ident).as_c_str |name| {
+ do cx.sess.str_of(ident).as_c_str |linkage| {
unsafe {
llvm::LLVMDIBuilderCreateFunction(
DIB(cx),
let work_dir = cx.sess.working_dir.to_str();
let producer = fmt!("rustc version %s", env!("CFG_VERSION"));
- do as_c_str(crate_name) |crate_name| {
- do as_c_str(work_dir) |work_dir| {
- do as_c_str(producer) |producer| {
- do as_c_str("") |flags| {
- do as_c_str("") |split_name| {
+ do crate_name.as_c_str |crate_name| {
+ do work_dir.as_c_str |work_dir| {
+ do producer.as_c_str |producer| {
+ do "".as_c_str |flags| {
+ do "".as_c_str |split_name| {
unsafe {
llvm::LLVMDIBuilderCreateCompileUnit(dcx.builder,
DW_LANG_RUST as c_uint, crate_name, work_dir, producer,
};
let file_metadata =
- do as_c_str(file_name) |file_name| {
- do as_c_str(work_dir) |work_dir| {
+ do file_name.as_c_str |file_name| {
+ do work_dir.as_c_str |work_dir| {
unsafe {
llvm::LLVMDIBuilderCreateFile(DIB(cx), file_name, work_dir)
}
let llvm_type = type_of::type_of(cx, t);
let (size, align) = size_and_align_of(cx, llvm_type);
- let ty_metadata = do as_c_str(name) |name| {
+ let ty_metadata = do name.as_c_str |name| {
unsafe {
llvm::LLVMDIBuilderCreateBasicType(
DIB(cx),
let pointer_llvm_type = type_of::type_of(cx, pointer_type);
let (pointer_size, pointer_align) = size_and_align_of(cx, pointer_llvm_type);
let name = ty_to_str(cx.tcx, pointer_type);
- let ptr_metadata = do as_c_str(name) |name| {
+ let ptr_metadata = do name.as_c_str |name| {
unsafe {
llvm::LLVMDIBuilderCreatePointerType(
DIB(cx),
debug!("unimplemented_type_metadata: %?", ty::get(t));
let name = ty_to_str(cx.tcx, t);
- let metadata = do as_c_str(fmt!("NYI<%s>", name)) |name| {
+ let metadata = do fmt!("NYI<%s>", name).as_c_str |name| {
unsafe {
llvm::LLVMDIBuilderCreateBasicType(
DIB(cx),
use std::io;
use std::libc::c_uint;
-use std::str;
use syntax::ast;
pub fn trans_free(cx: block, v: ValueRef) -> block {
let name = mangle_internal_name_by_type_and_seq(ccx, t, "tydesc").to_managed();
note_unique_llvm_symbol(ccx, name);
debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), name);
- let gvar = str::as_c_str(name, |buf| {
+ let gvar = do name.as_c_str |buf| {
unsafe {
llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type.to_ref(), buf)
}
- });
+ };
let inf = @mut tydesc_info {
ty: t,
tydesc: gvar,
pub fn link_exe(src: &Path, dest: &Path) -> bool {
use std::{libc, str};
unsafe {
- do str::as_c_str(src.to_str()) |src_buf| {
- do str::as_c_str(dest.to_str()) |dest_buf| {
+ do src.to_str().as_c_str |src_buf| {
+ do dest.to_str().as_c_str |dest_buf| {
libc::link(src_buf, dest_buf) == 0 as libc::c_int &&
libc::chmod(dest_buf, 755) == 0 as libc::c_int
}
use ptr;
use result;
use str;
-use str::{StrSlice, OwnedStr, StrUtil};
+use str::{StrSlice, OwnedStr};
use to_str::ToStr;
use uint;
use vec;
pub fn getenv(n: &str) -> Option<~str> {
unsafe {
do with_env_lock {
- let s = str::as_c_str(n, |s| libc::getenv(s));
+ let s = n.as_c_str(|s| libc::getenv(s as *libc::c_char));
if ptr::null::<u8>() == cast::transmute(s) {
- None::<~str>
+ None
} else {
- let s = cast::transmute(s);
- Some::<~str>(str::raw::from_buf(s))
+ Some(str::raw::from_buf(cast::transmute(s)))
}
}
}
pub fn setenv(n: &str, v: &str) {
unsafe {
do with_env_lock {
- do str::as_c_str(n) |nbuf| {
- do str::as_c_str(v) |vbuf| {
+ do n.to_str().as_c_str |nbuf| {
+ do v.to_str().as_c_str |vbuf| {
libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1);
}
}
fn _unsetenv(n: &str) {
unsafe {
do with_env_lock {
- do str::as_c_str(n) |nbuf| {
+ do n.to_str().as_c_str |nbuf| {
libc::funcs::posix01::unistd::unsetenv(nbuf);
}
}
use libc::funcs::posix01::unistd::readlink;
let mut path_str = str::with_capacity(TMPBUF_SZ);
- let len = do str::as_c_str(path_str) |buf| {
+ let len = do path_str.as_c_str |buf| {
let buf = buf as *mut c_char;
do "/proc/self/exe".as_c_str |proc_self_buf| {
readlink(proc_self_buf, buf, TMPBUF_SZ as size_t)
/// Indicates whether a path represents a directory
pub fn path_is_dir(p: &Path) -> bool {
unsafe {
- do str::as_c_str(p.to_str()) |buf| {
+ do p.to_str().as_c_str |buf| {
rustrt::rust_path_is_dir(buf) != 0 as c_int
}
}
/// Indicates whether a path exists
pub fn path_exists(p: &Path) -> bool {
unsafe {
- do str::as_c_str(p.to_str()) |buf| {
+ do p.to_str().as_c_str |buf| {
rustrt::rust_path_exists(buf) != 0 as c_int
}
}
fclose(ostream);
// Give the new file the old file's permissions
- if do str::as_c_str(to.to_str()) |to_buf| {
+ if do to.to_str().as_c_str |to_buf| {
libc::chmod(to_buf, from_mode as libc::mode_t)
} != 0 {
return false; // should be a condition...
}
let mut g = default_glob_t();
- do str::as_c_str(pattern) |c_pattern| {
+ do pattern.as_c_str |c_pattern| {
unsafe { libc::glob(c_pattern, 0, ptr::null(), &mut g) }
};
do(|| {
use libc;
use option::{None, Option, Some};
use str::{OwnedStr, Str, StrSlice, StrVector};
-use str;
use to_str::ToStr;
use ascii::{AsciiCast, AsciiStr};
use vec::{OwnedVector, ImmutableVector};
#[cfg(target_os = "win32")]
impl WindowsPath {
pub fn stat(&self) -> Option<libc::stat> {
- unsafe {
- do str::as_c_str(self.to_str()) |buf| {
- let mut st = stat::arch::default_stat();
- match libc::stat(buf, &mut st) {
- 0 => Some(st),
- _ => None,
- }
+ do self.to_str().as_c_str |buf| {
+ let mut st = stat::arch::default_stat();
+ match unsafe { libc::stat(buf, &mut st) } {
+ 0 => Some(st),
+ _ => None,
}
}
}
#[cfg(not(target_os = "win32"))]
impl PosixPath {
pub fn stat(&self) -> Option<libc::stat> {
- unsafe {
- do str::as_c_str(self.to_str()) |buf| {
- let mut st = stat::arch::default_stat();
- match libc::stat(buf, &mut st) {
- 0 => Some(st),
- _ => None,
- }
+ do self.to_str().as_c_str |buf| {
+ let mut st = stat::arch::default_stat();
+ match unsafe { libc::stat(buf as *libc::c_char, &mut st) } {
+ 0 => Some(st),
+ _ => None,
}
}
}
#[cfg(unix)]
impl PosixPath {
pub fn lstat(&self) -> Option<libc::stat> {
- unsafe {
- do str::as_c_str(self.to_str()) |buf| {
- let mut st = stat::arch::default_stat();
- match libc::lstat(buf, &mut st) {
- 0 => Some(st),
- _ => None,
- }
+ do self.to_str().as_c_str |buf| {
+ let mut st = stat::arch::default_stat();
+ match unsafe { libc::lstat(buf, &mut st) } {
+ 0 => Some(st),
+ _ => None,
}
}
}
pub use path::WindowsPath;
pub use ptr::RawPtr;
pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, ToBytesConsume};
-pub use str::{Str, StrVector, StrSlice, OwnedStr, StrUtil, NullTerminatedStr};
+pub use str::{Str, StrVector, StrSlice, OwnedStr, NullTerminatedStr};
pub use from_str::{FromStr};
pub use to_bytes::IterBytes;
pub use to_str::{ToStr, ToStrConsume};
#[test]
fn test_position() {
- use str::as_c_str;
use libc::c_char;
let s = ~"hello";
unsafe {
- assert!(2u == as_c_str(s, |p| position(p,
- |c| *c == 'l' as c_char)));
- assert!(4u == as_c_str(s, |p| position(p,
- |c| *c == 'o' as c_char)));
- assert!(5u == as_c_str(s, |p| position(p,
- |c| *c == 0 as c_char)));
+ assert!(2u == s.as_c_str(|p| position(p, |c| *c == 'l' as c_char)));
+ assert!(4u == s.as_c_str(|p| position(p, |c| *c == 'o' as c_char)));
+ assert!(5u == s.as_c_str(|p| position(p, |c| *c == 0 as c_char)));
}
}
let s0 = ~"hello";
let s1 = ~"there";
let s2 = ~"thing";
- do str::as_c_str(s0) |p0| {
- do str::as_c_str(s1) |p1| {
- do str::as_c_str(s2) |p2| {
+ do s0.as_c_str |p0| {
+ do s1.as_c_str |p1| {
+ do s2.as_c_str |p2| {
let v = ~[p0, p1, p2, null()];
do v.as_imm_buf |vp, len| {
assert_eq!(unsafe { buf_len(vp) }, 3u);
/// per-module global logging flags based on the logging spec
pub fn init(crate_map: *u8) {
use os;
- use str;
+ use str::StrSlice;
use ptr;
use option::{Some, None};
let log_spec = os::getenv("RUST_LOG");
match log_spec {
Some(spec) => {
- do str::as_c_str(spec) |s| {
- unsafe {
- rust_update_log_settings(crate_map, s);
- }
+ do spec.as_c_str |buf| {
+ unsafe { rust_update_log_settings(crate_map, buf) }
}
}
None => {
}
pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
- do str::as_c_str(ip) |ip_buf| {
+ do ip.as_c_str |ip_buf| {
rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
}
}
pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
- do str::as_c_str(ip) |ip_buf| {
+ do ip.as_c_str |ip_buf| {
rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
}
}
do with_envp(env) |envp| {
do with_dirp(dir) |dirp| {
- do str::as_c_str(cmd) |cmdp| {
+ do cmd.as_c_str |cmdp| {
let created = CreateProcessA(ptr::null(), cast::transmute(cmdp),
ptr::mut_null(), ptr::mut_null(), TRUE,
0, envp, dirp, &mut si, &mut pi);
#[cfg(unix)]
fn with_argv<T>(prog: &str, args: &[~str],
cb: &fn(**libc::c_char) -> T) -> T {
- let mut argptrs = ~[str::as_c_str(prog, |b| b)];
+ let mut argptrs = ~[prog.as_c_str(|b| b)];
let mut tmps = ~[];
for args.iter().advance |arg| {
let t = @(*arg).clone();
tmps.push(t);
- argptrs.push(str::as_c_str(*t, |b| b));
+ argptrs.push(t.as_c_str(|b| b));
}
argptrs.push(ptr::null());
argptrs.as_imm_buf(|buf, _len| cb(buf))
&(ref k, ref v) => {
let kv = @fmt!("%s=%s", *k, *v);
tmps.push(kv);
- ptrs.push(str::as_c_str(*kv, |b| b));
+ ptrs.push(kv.as_c_str(|b| b));
}
}
}
fn with_dirp<T>(d: Option<&Path>,
cb: &fn(*libc::c_char) -> T) -> T {
match d {
- Some(dir) => str::as_c_str(dir.to_str(), cb),
+ Some(dir) => dir.to_str().as_c_str(cb),
None => cb(ptr::null())
}
}
static MAX_THREE_B: uint = 65536u;
static TAG_FOUR_B: uint = 240u;
-/**
- * A dummy trait to hold all the utility methods that we implement on strings.
- */
-pub trait StrUtil {
- /**
- * Work with the byte buffer of a string as a null-terminated C string.
- *
- * Allows for unsafe manipulation of strings, which is useful for foreign
- * interop. This is similar to `str::as_buf`, but guarantees null-termination.
- * If the given slice is not already null-terminated, this function will
- * allocate a temporary, copy the slice, null terminate it, and pass
- * that instead.
- *
- * # Example
- *
- * ~~~ {.rust}
- * let s = "PATH".as_c_str(|path| libc::getenv(path));
- * ~~~
- */
- fn as_c_str<T>(self, f: &fn(*libc::c_char) -> T) -> T;
-}
-
-impl<'self> StrUtil for &'self str {
- #[inline]
- fn as_c_str<T>(self, f: &fn(*libc::c_char) -> T) -> T {
- do self.as_buf |buf, len| {
- // NB: len includes the trailing null.
- assert!(len > 0);
- if unsafe { *(ptr::offset(buf,len-1)) != 0 } {
- to_owned(self).as_c_str(|s| f(s))
- } else {
- f(buf as *libc::c_char)
- }
- }
- }
-}
-
-/**
- * Deprecated. Use the `as_c_str` method on strings instead.
- */
-#[inline]
-pub fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T {
- s.as_c_str(f)
-}
-
/// Unsafe operations
pub mod raw {
use cast;
fn subslice_offset(&self, inner: &str) -> uint;
fn as_buf<T>(&self, f: &fn(*u8, uint) -> T) -> T;
+ fn as_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T;
}
/// Extension methods for strings
f(buf, len)
}
}
+
+ /**
+ * Work with the byte buffer of a string as a null-terminated C string.
+ *
+ * Allows for unsafe manipulation of strings, which is useful for foreign
+ * interop. This is similar to `str::as_buf`, but guarantees null-termination.
+ * If the given slice is not already null-terminated, this function will
+ * allocate a temporary, copy the slice, null terminate it, and pass
+ * that instead.
+ *
+ * # Example
+ *
+ * ~~~ {.rust}
+ * let s = "PATH".as_c_str(|path| libc::getenv(path));
+ * ~~~
+ */
+ #[inline]
+ fn as_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+ do self.as_buf |buf, len| {
+ // NB: len includes the trailing null.
+ assert!(len > 0);
+ if unsafe { *(ptr::offset(buf, len - 1)) != 0 } {
+ self.to_owned().as_c_str(|s| f(s))
+ } else {
+ f(buf as *libc::c_char)
+ }
+ }
+ }
}
#[allow(missing_doc)]
projects / rust.git / commitdiff