From ec5911b2a62b0d603da7deb18c34c8e853c91d2c Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Mon, 12 May 2014 21:12:50 -0700 Subject: [PATCH] libregex: Remove all uses of `~str` from `libregex` --- src/libregex/compile.rs | 8 ++++---- src/libregex/parse.rs | 34 +++++++++++++++++----------------- src/libregex/re.rs | 35 ++++++++++++++++++++--------------- src/libregex/test/bench.rs | 6 +++--- src/libregex_macros/lib.rs | 12 ++++++------ 5 files changed, 50 insertions(+), 45 deletions(-) diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs index e5166c6c17c..1ba69104446 100644 --- a/src/libregex/compile.rs +++ b/src/libregex/compile.rs @@ -83,12 +83,12 @@ pub struct Program { /// If the regular expression requires a literal prefix in order to have a /// match, that prefix is stored here. (It's used in the VM to implement /// an optimization.) - pub prefix: ~str, + pub prefix: StrBuf, } impl Program { /// Compiles a Regex given its AST. - pub fn new(ast: parse::Ast) -> (Program, Vec>) { + pub fn new(ast: parse::Ast) -> (Program, Vec>) { let mut c = Compiler { insts: Vec::with_capacity(100), names: Vec::with_capacity(10), @@ -113,7 +113,7 @@ impl Program { let Compiler { insts, names } = c; let prog = Program { insts: insts, - prefix: pre.into_owned(), + prefix: pre, }; (prog, names) } @@ -135,7 +135,7 @@ impl Program { struct Compiler<'r> { insts: Vec, - names: Vec>, + names: Vec>, } // The compiler implemented here is extremely simple. Most of the complexity diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index 3a28f0d1ed5..d1a01cc974f 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -32,7 +32,7 @@ pub struct Error { /// The *approximate* character index of where the error occurred. pub pos: uint, /// A message describing the error. - pub msg: ~str, + pub msg: StrBuf, } impl fmt::Show for Error { @@ -59,7 +59,7 @@ pub enum Ast { Begin(Flags), End(Flags), WordBoundary(Flags), - Capture(uint, Option<~str>, Box), + Capture(uint, Option, Box), // Represent concatenation as a flat vector to avoid blowing the // stack in the compiler. Cat(Vec), @@ -104,7 +104,7 @@ impl Greed { #[deriving(Show)] enum BuildAst { Ast(Ast), - Paren(Flags, uint, ~str), // '(' + Paren(Flags, uint, StrBuf), // '(' Bar, // '|' } @@ -131,7 +131,7 @@ impl BuildAst { } } - fn capture_name(&self) -> Option<~str> { + fn capture_name(&self) -> Option { match *self { Paren(_, 0, _) => None, Paren(_, _, ref name) => { @@ -185,7 +185,7 @@ struct Parser<'a> { // opening a capture group). caps: uint, // A set of all capture group names used only to detect duplicates. - names: Vec<~str>, + names: Vec, } pub fn parse(s: &str) -> Result { @@ -222,7 +222,7 @@ impl<'a> Parser<'a> { self.caps += 1; self.stack.push(Paren(self.flags, self.caps, - "".to_owned())) + "".to_strbuf())) } } ')' => { @@ -470,7 +470,7 @@ impl<'a> Parser<'a> { FLAG_EMPTY }; let name = self.slice(name_start, closer - 1); - match find_class(ASCII_CLASSES, name) { + match find_class(ASCII_CLASSES, name.as_slice()) { None => None, Some(ranges) => { self.chari = closer; @@ -611,7 +611,7 @@ impl<'a> Parser<'a> { // character). fn parse_unicode_name(&mut self) -> Result { let negated = if self.cur() == 'P' { FLAG_NEGATED } else { FLAG_EMPTY }; - let mut name: ~str; + let mut name: StrBuf; if self.peek_is(1, '{') { try!(self.expect('{')) let closer = @@ -633,7 +633,7 @@ impl<'a> Parser<'a> { name = self.slice(self.chari + 1, self.chari + 2); self.chari += 1; } - match find_class(UNICODE_CLASSES, name) { + match find_class(UNICODE_CLASSES, name.as_slice()) { None => return self.err(format!( "Could not find Unicode class '{}'", name)), Some(ranges) => { @@ -657,7 +657,7 @@ impl<'a> Parser<'a> { } } let s = self.slice(start, end); - match num::from_str_radix::(s, 8) { + match num::from_str_radix::(s.as_slice(), 8) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), None => self.err(format!( "Could not parse '{}' as octal number.", s)), @@ -679,7 +679,7 @@ impl<'a> Parser<'a> { Some(i) => i, }; self.chari = closer; - self.parse_hex_digits(self.slice(start, closer)) + self.parse_hex_digits(self.slice(start, closer).as_slice()) } // Parses a two-digit hex number. @@ -690,7 +690,7 @@ impl<'a> Parser<'a> { let (start, end) = (self.chari, self.chari + 2); let bad = self.slice(start - 2, self.chars.len()); try!(self.noteof(format!("Invalid hex escape sequence '{}'", bad))) - self.parse_hex_digits(self.slice(start, end)) + self.parse_hex_digits(self.slice(start, end).as_slice()) } // Parses `s` as a hexadecimal number. @@ -717,7 +717,7 @@ impl<'a> Parser<'a> { return self.err("Capture names must have at least 1 character.") } let name = self.slice(self.chari, closer); - if !name.chars().all(is_valid_cap) { + if !name.as_slice().chars().all(is_valid_cap) { return self.err( "Capture names can only have underscores, letters and digits.") } @@ -771,7 +771,7 @@ impl<'a> Parser<'a> { } if self.cur() == ':' { // Save the old flags with the opening paren. - self.stack.push(Paren(self.flags, 0, "".to_owned())); + self.stack.push(Paren(self.flags, 0, "".to_strbuf())); } self.flags = flags; return Ok(()) @@ -892,7 +892,7 @@ impl<'a> Parser<'a> { fn err(&self, msg: &str) -> Result { Err(Error { pos: self.chari, - msg: msg.to_owned(), + msg: msg.to_strbuf(), }) } @@ -911,8 +911,8 @@ impl<'a> Parser<'a> { *self.chars.get(self.chari) } - fn slice(&self, start: uint, end: uint) -> ~str { - str::from_chars(self.chars.as_slice().slice(start, end)) + fn slice(&self, start: uint, end: uint) -> StrBuf { + str::from_chars(self.chars.as_slice().slice(start, end)).to_strbuf() } } diff --git a/src/libregex/re.rs b/src/libregex/re.rs index b40968283bd..f22889b22a3 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -20,7 +20,7 @@ use vm::{CaptureLocs, MatchKind, Exists, Location, Submatches}; /// Escapes all regular expression meta characters in `text` so that it may be /// safely used in a regular expression as a literal string. -pub fn quote(text: &str) -> ~str { +pub fn quote(text: &str) -> StrBuf { let mut quoted = StrBuf::with_capacity(text.len()); for c in text.chars() { if parse::is_punct(c) { @@ -28,7 +28,7 @@ pub fn quote(text: &str) -> ~str { } quoted.push_char(c); } - quoted.into_owned() + quoted } /// Tests if the given regular expression matches somewhere in the text given. @@ -107,9 +107,9 @@ pub struct Regex { /// See the comments for the `program` module in `lib.rs` for a more /// detailed explanation for what `regex!` requires. #[doc(hidden)] - pub original: ~str, + pub original: StrBuf, #[doc(hidden)] - pub names: Vec>, + pub names: Vec>, #[doc(hidden)] pub p: MaybeNative, } @@ -146,7 +146,10 @@ impl Regex { pub fn new(re: &str) -> Result { let ast = try!(parse::parse(re)); let (prog, names) = Program::new(ast); - Ok(Regex { original: re.to_owned(), names: names, p: Dynamic(prog) }) + Ok(Regex { + original: re.to_strbuf(), + names: names, p: Dynamic(prog), + }) } /// Returns true if and only if the regex matches the string given. @@ -404,7 +407,7 @@ impl Regex { /// ``` /// /// But anything satisfying the `Replacer` trait will work. For example, - /// a closure of type `|&Captures| -> ~str` provides direct access to the + /// a closure of type `|&Captures| -> StrBuf` provides direct access to the /// captures corresponding to a match. This allows one to access /// submatches easily: /// @@ -414,7 +417,7 @@ impl Regex { /// # use regex::Captures; fn main() { /// let re = regex!(r"([^,\s]+),\s+(\S+)"); /// let result = re.replace("Springsteen, Bruce", |caps: &Captures| { - /// format!("{} {}", caps.at(2), caps.at(1)) + /// format_strbuf!("{} {}", caps.at(2), caps.at(1)) /// }); /// assert_eq!(result.as_slice(), "Bruce Springsteen"); /// # } @@ -526,7 +529,7 @@ impl<'t> Replacer for &'t str { } } -impl<'a> Replacer for |&Captures|: 'a -> ~str { +impl<'a> Replacer for |&Captures|: 'a -> StrBuf { fn reg_replace<'r>(&'r mut self, caps: &Captures) -> MaybeOwned<'r> { Owned((*self)(caps).into_owned()) } @@ -605,7 +608,7 @@ impl<'r, 't> Iterator<&'t str> for RegexSplitsN<'r, 't> { pub struct Captures<'t> { text: &'t str, locs: CaptureLocs, - named: Option>, + named: Option>, } impl<'t> Captures<'t> { @@ -624,7 +627,7 @@ impl<'t> Captures<'t> { match name { &None => {}, &Some(ref name) => { - named.insert(name.to_owned(), i); + named.insert(name.to_strbuf(), i); } } } @@ -707,12 +710,14 @@ impl<'t> Captures<'t> { // How evil can you get? // FIXME: Don't use regexes for this. It's completely unnecessary. let re = Regex::new(r"(^|[^$]|\b)\$(\w+)").unwrap(); - let text = re.replace_all(text, |refs: &Captures| -> ~str { + let text = re.replace_all(text, |refs: &Captures| -> StrBuf { let (pre, name) = (refs.at(1), refs.at(2)); - pre + match from_str::(name) { - None => self.name(name).to_owned(), - Some(i) => self.at(i).to_owned(), - } + format_strbuf!("{}{}", + pre, + match from_str::(name.as_slice()) { + None => self.name(name).to_strbuf(), + Some(i) => self.at(i).to_strbuf(), + }) }); let re = Regex::new(r"\$\$").unwrap(); re.replace_all(text.as_slice(), NoExpand("$")) diff --git a/src/libregex/test/bench.rs b/src/libregex/test/bench.rs index 17c66bc670a..3630e0ebb5c 100644 --- a/src/libregex/test/bench.rs +++ b/src/libregex/test/bench.rs @@ -140,7 +140,7 @@ macro_rules! throughput( fn $name(b: &mut Bencher) { let text = gen_text($size); b.bytes = $size; - b.iter(|| if $regex.is_match(text) { fail!("match") }); + b.iter(|| if $regex.is_match(text.as_slice()) { fail!("match") }); } ); ) @@ -151,7 +151,7 @@ fn medium() -> Regex { regex!("[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$") } fn hard() -> Regex { regex!("[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$") } #[allow(deprecated_owned_vector)] -fn gen_text(n: uint) -> ~str { +fn gen_text(n: uint) -> StrBuf { let mut rng = task_rng(); let mut bytes = rng.gen_ascii_str(n).into_bytes(); for (i, b) in bytes.mut_iter().enumerate() { @@ -159,7 +159,7 @@ fn gen_text(n: uint) -> ~str { *b = '\n' as u8 } } - str::from_utf8(bytes).unwrap().to_owned() + str::from_utf8(bytes).unwrap().to_strbuf() } throughput!(easy0_32, easy0(), 32) diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs index 9d25adacd81..b85a1592eff 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -105,8 +105,8 @@ struct NfaGen<'a> { cx: &'a ExtCtxt<'a>, sp: codemap::Span, prog: Program, - names: Vec>, - original: ~str, + names: Vec>, + original: StrBuf, } impl<'a> NfaGen<'a> { @@ -119,7 +119,7 @@ impl<'a> NfaGen<'a> { |cx, name| match *name { Some(ref name) => { let name = name.as_slice(); - quote_expr!(cx, Some($name.to_owned())) + quote_expr!(cx, Some($name.to_strbuf())) } None => cx.expr_none(self.sp), } @@ -311,7 +311,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, } ::regex::Regex { - original: $regex.to_owned(), + original: $regex.to_strbuf(), names: vec!$cap_names, p: ::regex::native::Native(exec), } @@ -601,14 +601,14 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, /// Looks for a single string literal and returns it. /// Otherwise, logs an error with cx.span_err and returns None. -fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option<~str> { +fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option { let mut parser = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), Vec::from_slice(tts)); let entry = cx.expand_expr(parser.parse_expr()); let regex = match entry.node { ast::ExprLit(lit) => { match lit.node { - ast::LitStr(ref s, _) => s.to_str(), + ast::LitStr(ref s, _) => s.to_str().to_strbuf(), _ => { cx.span_err(entry.span, format!( "expected string literal but got `{}`",