Switched over a bunch of splitting funktions to non-allocating iterators
This commit is contained in:
parent
d74606ead6
commit
b9de2b5787
13 changed files with 135 additions and 98 deletions
|
@ -132,10 +132,10 @@ impl_NumStrConv_Integer!(u64)
|
||||||
|
|
||||||
|
|
||||||
// Special value strings as [u8] consts.
|
// Special value strings as [u8] consts.
|
||||||
const inf_buf: [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
|
static inf_buf: [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
|
||||||
const positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
|
static positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
|
||||||
const negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
|
static negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
|
||||||
const nan_buf: [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
|
static nan_buf: [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Converts a number to its string representation as a byte vector.
|
* Converts a number to its string representation as a byte vector.
|
||||||
|
|
|
@ -218,7 +218,8 @@ pub fn env() -> ~[(~str,~str)] {
|
||||||
fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
|
fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
|
||||||
let mut pairs = ~[];
|
let mut pairs = ~[];
|
||||||
for input.each |p| {
|
for input.each |p| {
|
||||||
let vs = str::splitn_char(*p, '=', 1);
|
let mut vs = ~[];
|
||||||
|
for str::each_splitn_char(*p, '=', 1) |s| { vs.push(s.to_owned()) }
|
||||||
debug!("splitting: len: %u",
|
debug!("splitting: len: %u",
|
||||||
vs.len());
|
vs.len());
|
||||||
fail_unless!(vs.len() == 2);
|
fail_unless!(vs.len() == 2);
|
||||||
|
|
|
@ -381,7 +381,8 @@ impl ToStr for PosixPath {
|
||||||
impl GenericPath for PosixPath {
|
impl GenericPath for PosixPath {
|
||||||
|
|
||||||
fn from_str(s: &str) -> PosixPath {
|
fn from_str(s: &str) -> PosixPath {
|
||||||
let mut components = str::split_nonempty(s, |c| c == '/');
|
let mut components = ~[];
|
||||||
|
for str::each_split_nonempty(s, |c| c == '/') |s| { components.push(s.to_owned()) }
|
||||||
let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
|
let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
|
||||||
return PosixPath { is_absolute: is_absolute,
|
return PosixPath { is_absolute: is_absolute,
|
||||||
components: components }
|
components: components }
|
||||||
|
@ -504,9 +505,10 @@ impl GenericPath for PosixPath {
|
||||||
fn push_many(&self, cs: &[~str]) -> PosixPath {
|
fn push_many(&self, cs: &[~str]) -> PosixPath {
|
||||||
let mut v = copy self.components;
|
let mut v = copy self.components;
|
||||||
for cs.each |e| {
|
for cs.each |e| {
|
||||||
let mut ss = str::split_nonempty(
|
let mut ss = ~[];
|
||||||
*e,
|
for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
|
||||||
|c| windows::is_sep(c as u8));
|
ss.push(s.to_owned())
|
||||||
|
}
|
||||||
unsafe { v.push_all_move(ss); }
|
unsafe { v.push_all_move(ss); }
|
||||||
}
|
}
|
||||||
PosixPath { is_absolute: self.is_absolute,
|
PosixPath { is_absolute: self.is_absolute,
|
||||||
|
@ -515,7 +517,10 @@ impl GenericPath for PosixPath {
|
||||||
|
|
||||||
fn push(&self, s: &str) -> PosixPath {
|
fn push(&self, s: &str) -> PosixPath {
|
||||||
let mut v = copy self.components;
|
let mut v = copy self.components;
|
||||||
let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
|
let mut ss = ~[];
|
||||||
|
for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
|
||||||
|
ss.push(s.to_owned())
|
||||||
|
}
|
||||||
unsafe { v.push_all_move(ss); }
|
unsafe { v.push_all_move(ss); }
|
||||||
PosixPath { components: v, ..copy *self }
|
PosixPath { components: v, ..copy *self }
|
||||||
}
|
}
|
||||||
|
@ -590,8 +595,10 @@ impl GenericPath for WindowsPath {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
let mut components =
|
let mut components = ~[];
|
||||||
str::split_nonempty(rest, |c| windows::is_sep(c as u8));
|
for str::each_split_nonempty(rest, |c| windows::is_sep(c as u8)) |s| {
|
||||||
|
components.push(s.to_owned())
|
||||||
|
}
|
||||||
let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
|
let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
|
||||||
return WindowsPath { host: host,
|
return WindowsPath { host: host,
|
||||||
device: device,
|
device: device,
|
||||||
|
@ -759,9 +766,10 @@ impl GenericPath for WindowsPath {
|
||||||
fn push_many(&self, cs: &[~str]) -> WindowsPath {
|
fn push_many(&self, cs: &[~str]) -> WindowsPath {
|
||||||
let mut v = copy self.components;
|
let mut v = copy self.components;
|
||||||
for cs.each |e| {
|
for cs.each |e| {
|
||||||
let mut ss = str::split_nonempty(
|
let mut ss = ~[];
|
||||||
*e,
|
for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
|
||||||
|c| windows::is_sep(c as u8));
|
ss.push(s.to_owned())
|
||||||
|
}
|
||||||
unsafe { v.push_all_move(ss); }
|
unsafe { v.push_all_move(ss); }
|
||||||
}
|
}
|
||||||
// tedious, but as-is, we can't use ..self
|
// tedious, but as-is, we can't use ..self
|
||||||
|
@ -775,7 +783,10 @@ impl GenericPath for WindowsPath {
|
||||||
|
|
||||||
fn push(&self, s: &str) -> WindowsPath {
|
fn push(&self, s: &str) -> WindowsPath {
|
||||||
let mut v = copy self.components;
|
let mut v = copy self.components;
|
||||||
let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
|
let mut ss = ~[];
|
||||||
|
for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
|
||||||
|
ss.push(s.to_owned())
|
||||||
|
}
|
||||||
unsafe { v.push_all_move(ss); }
|
unsafe { v.push_all_move(ss); }
|
||||||
return WindowsPath { components: v, ..copy *self }
|
return WindowsPath { components: v, ..copy *self }
|
||||||
}
|
}
|
||||||
|
|
|
@ -327,7 +327,9 @@ impl RngUtil for @Rng {
|
||||||
*/
|
*/
|
||||||
fn gen_char_from(&self, chars: &str) -> char {
|
fn gen_char_from(&self, chars: &str) -> char {
|
||||||
fail_unless!(!chars.is_empty());
|
fail_unless!(!chars.is_empty());
|
||||||
self.choose(str::chars(chars))
|
let mut cs = ~[];
|
||||||
|
for str::each_char(chars) |c| { cs.push(c) }
|
||||||
|
self.choose(cs)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Return a random bool
|
/// Return a random bool
|
||||||
|
|
|
@ -463,7 +463,7 @@ pub fn each_split_char_nonempty(s: &str, sep: char, it: &fn(&str) -> bool) {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn each_split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool,
|
fn each_split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool,
|
||||||
allow_trailing_empty: bool), it: &fn(&str) -> bool) {
|
allow_trailing_empty: bool, it: &fn(&str) -> bool) {
|
||||||
if sep < 128u as char {
|
if sep < 128u as char {
|
||||||
let b = sep as u8, l = len(s);
|
let b = sep as u8, l = len(s);
|
||||||
let mut done = 0u;
|
let mut done = 0u;
|
||||||
|
@ -513,8 +513,8 @@ pub fn each_split_nonempty(s: &str, sepfn: &fn(char) -> bool, it: &fn(&str) -> b
|
||||||
each_split_inner(s, sepfn, len(s), false, false, it)
|
each_split_inner(s, sepfn, len(s), false, false, it)
|
||||||
}
|
}
|
||||||
|
|
||||||
pure fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
|
fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
|
||||||
allow_empty: bool, allow_trailing_empty: bool), it: &fn(&str) -> bool) {
|
allow_empty: bool, allow_trailing_empty: bool, it: &fn(&str) -> bool) {
|
||||||
let l = len(s);
|
let l = len(s);
|
||||||
let mut i = 0u, start = 0u, done = 0u;
|
let mut i = 0u, start = 0u, done = 0u;
|
||||||
while i < l && done < count {
|
while i < l && done < count {
|
||||||
|
@ -534,7 +534,7 @@ pure fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
|
||||||
}
|
}
|
||||||
|
|
||||||
// See Issue #1932 for why this is a naive search
|
// See Issue #1932 for why this is a naive search
|
||||||
fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
|
fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
|
||||||
let sep_len = len(sep), l = len(s);
|
let sep_len = len(sep), l = len(s);
|
||||||
fail_unless!(sep_len > 0u);
|
fail_unless!(sep_len > 0u);
|
||||||
let mut i = 0u, match_start = 0u, match_i = 0u;
|
let mut i = 0u, match_start = 0u, match_i = 0u;
|
||||||
|
@ -545,7 +545,7 @@ fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
|
||||||
match_i += 1u;
|
match_i += 1u;
|
||||||
// Found a match
|
// Found a match
|
||||||
if match_i == sep_len {
|
if match_i == sep_len {
|
||||||
f(match_start, i + 1u);
|
if !f(match_start, i + 1u) { return; }
|
||||||
match_i = 0u;
|
match_i = 0u;
|
||||||
}
|
}
|
||||||
i += 1u;
|
i += 1u;
|
||||||
|
@ -561,10 +561,10 @@ fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
|
fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
|
||||||
let mut last_end = 0u;
|
let mut last_end = 0u;
|
||||||
do iter_matches(s, sep) |from, to| {
|
for iter_matches(s, sep) |from, to| {
|
||||||
f(last_end, from);
|
if !f(last_end, from) { return; }
|
||||||
last_end = to;
|
last_end = to;
|
||||||
}
|
}
|
||||||
f(last_end, len(s));
|
f(last_end, len(s));
|
||||||
|
@ -580,13 +580,13 @@ fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
|
||||||
* ~~~
|
* ~~~
|
||||||
*/
|
*/
|
||||||
pub fn each_split_str(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
|
pub fn each_split_str(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
|
||||||
do iter_between_matches(s, sep) |from, to| {
|
for iter_between_matches(s, sep) |from, to| {
|
||||||
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
|
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn each_split_str_nonempty(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
|
pub fn each_split_str_nonempty(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
|
||||||
do iter_between_matches(s, sep) |from, to| {
|
for iter_between_matches(s, sep) |from, to| {
|
||||||
if to > from {
|
if to > from {
|
||||||
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
|
if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
|
||||||
}
|
}
|
||||||
|
@ -630,7 +630,7 @@ pub fn levdistance(s: &str, t: &str) -> uint {
|
||||||
/**
|
/**
|
||||||
* Splits a string into a vector of the substrings separated by LF ('\n').
|
* Splits a string into a vector of the substrings separated by LF ('\n').
|
||||||
*/
|
*/
|
||||||
pub fn each_line(s: &str, it: &fn(&str) -> bool) { each_split_char(s, '\n', it) }
|
pub fn each_line(s: &str, it: &fn(&str) -> bool) { each_split_char_no_trailing(s, '\n', it) }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Splits a string into a vector of the substrings separated by LF ('\n')
|
* Splits a string into a vector of the substrings separated by LF ('\n')
|
||||||
|
@ -656,52 +656,56 @@ pub fn each_word(s: &str, it: &fn(&str) -> bool) {
|
||||||
* each of which is less bytes long than a limit
|
* each of which is less bytes long than a limit
|
||||||
*/
|
*/
|
||||||
pub fn each_split_within(ss: &str, lim: uint, it: &fn(&str) -> bool) {
|
pub fn each_split_within(ss: &str, lim: uint, it: &fn(&str) -> bool) {
|
||||||
let words = str::words(ss);
|
// Just for fun, let's write this as an automaton
|
||||||
|
enum SplitWithinState {
|
||||||
// empty?
|
A, // Leading whitespace, initial state
|
||||||
if words == ~[] { return ~[]; }
|
B, // Words
|
||||||
|
C, // Internal and trailing whitespace
|
||||||
let mut rows : ~[~str] = ~[];
|
|
||||||
let mut row : ~str = ~"";
|
|
||||||
|
|
||||||
for words.each |wptr| {
|
|
||||||
let word = copy *wptr;
|
|
||||||
|
|
||||||
// if adding this word to the row would go over the limit,
|
|
||||||
// then start a new row
|
|
||||||
if row.len() + word.len() + 1 > lim {
|
|
||||||
rows.push(copy row); // save previous row
|
|
||||||
row = word; // start a new one
|
|
||||||
} else {
|
|
||||||
if row.len() > 0 { row += ~" " } // separate words
|
|
||||||
row += word; // append to this row
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
enum Whitespace { Ws, Cr }
|
||||||
|
enum LengthLimit { UnderLim, OverLim }
|
||||||
|
|
||||||
// save the last row
|
let mut slice_start = 0;
|
||||||
if row != ~"" { rows.push(row); }
|
let mut last_start = 0;
|
||||||
|
let mut last_end = 0;
|
||||||
|
let mut state = A;
|
||||||
|
|
||||||
rows
|
let mut cont = true;
|
||||||
// NOTE: Finish change here
|
let slice = || { cont = it(ss.slice(slice_start, last_end)) };
|
||||||
|
|
||||||
let mut last_slice_i = 0, last_word_i = 0, word_start = true;
|
let machine = |i: uint, c: char| {
|
||||||
for each_chari(s) |i, c| {
|
let whitespace = if char::is_whitespace(c) { Ws } else { Cr };
|
||||||
if (i - last_slice_i) <= lim {
|
let limit = if (i - slice_start + 1) <= lim { UnderLim } else { OverLim };
|
||||||
if char::is_whitespace(c) {
|
|
||||||
|
|
||||||
} else {
|
state = match (state, whitespace, limit) {
|
||||||
|
(A, Ws, _) => { A }
|
||||||
|
(A, Cr, _) => { slice_start = i; last_start = i; B }
|
||||||
|
|
||||||
}
|
(B, Cr, UnderLim) => { B }
|
||||||
} else {
|
(B, Cr, OverLim) if (i - last_start + 1) > lim
|
||||||
|
=> { fail!(~"word longer than limit!") }
|
||||||
|
(B, Cr, OverLim) => { slice(); slice_start = last_start; B }
|
||||||
|
(B, Ws, UnderLim) => { last_end = i; C }
|
||||||
|
(B, Ws, OverLim) => { last_end = i; slice(); A }
|
||||||
|
|
||||||
}
|
(C, Cr, UnderLim) => { last_start = i; B }
|
||||||
|
(C, Cr, OverLim) => { slice(); slice_start = i; last_start = i; last_end = i; B }
|
||||||
|
(C, Ws, OverLim) => { slice(); A }
|
||||||
|
(C, Ws, UnderLim) => { C }
|
||||||
|
};
|
||||||
|
cont
|
||||||
|
};
|
||||||
|
|
||||||
|
str::each_chari(ss, machine);
|
||||||
|
|
||||||
|
// Let the automaton 'run out'
|
||||||
|
let mut fake_i = ss.len();
|
||||||
|
while cont && match state { B | C => true, A => false } {
|
||||||
|
machine(fake_i, ' ');
|
||||||
|
fake_i += 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/// Convert a string to lowercase. ASCII only
|
/// Convert a string to lowercase. ASCII only
|
||||||
pub fn to_lower(s: &str) -> ~str {
|
pub fn to_lower(s: &str) -> ~str {
|
||||||
map(s,
|
map(s,
|
||||||
|
@ -731,7 +735,7 @@ pub fn to_upper(s: &str) -> ~str {
|
||||||
*/
|
*/
|
||||||
pub fn replace(s: &str, from: &str, to: &str) -> ~str {
|
pub fn replace(s: &str, from: &str, to: &str) -> ~str {
|
||||||
let mut result = ~"", first = true;
|
let mut result = ~"", first = true;
|
||||||
do iter_between_matches(s, from) |start, end| {
|
for iter_between_matches(s, from) |start, end| {
|
||||||
if first {
|
if first {
|
||||||
first = false;
|
first = false;
|
||||||
} else {
|
} else {
|
||||||
|
@ -2286,9 +2290,9 @@ pub trait StrSlice {
|
||||||
fn len(&self) -> uint;
|
fn len(&self) -> uint;
|
||||||
fn char_len(&self) -> uint;
|
fn char_len(&self) -> uint;
|
||||||
fn slice(&self, begin: uint, end: uint) -> &'self str;
|
fn slice(&self, begin: uint, end: uint) -> &'self str;
|
||||||
fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str];
|
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&str) -> bool);
|
||||||
fn split_char(&self, sep: char) -> ~[~str];
|
fn each_split_char(&self, sep: char, it: &fn(&str) -> bool);
|
||||||
fn split_str(&self, sep: &'a str) -> ~[~str];
|
fn each_split_str(&self, sep: &'a str, it: &fn(&str) -> bool);
|
||||||
fn starts_with(&self, needle: &'a str) -> bool;
|
fn starts_with(&self, needle: &'a str) -> bool;
|
||||||
fn substr(&self, begin: uint, n: uint) -> &'self str;
|
fn substr(&self, begin: uint, n: uint) -> &'self str;
|
||||||
fn to_lower(&self) -> ~str;
|
fn to_lower(&self) -> ~str;
|
||||||
|
@ -2408,20 +2412,24 @@ impl StrSlice for &'self str {
|
||||||
}
|
}
|
||||||
/// Splits a string into substrings using a character function
|
/// Splits a string into substrings using a character function
|
||||||
#[inline]
|
#[inline]
|
||||||
fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str] {
|
fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&str) -> bool) {
|
||||||
split(*self, sepfn)
|
each_split(*self, sepfn, it)
|
||||||
}
|
}
|
||||||
/**
|
/**
|
||||||
* Splits a string into substrings at each occurrence of a given character
|
* Splits a string into substrings at each occurrence of a given character
|
||||||
*/
|
*/
|
||||||
#[inline]
|
#[inline]
|
||||||
fn split_char(&self, sep: char) -> ~[~str] { split_char(*self, sep) }
|
fn each_split_char(&self, sep: char, it: &fn(&str) -> bool) {
|
||||||
|
each_split_char(*self, sep, it)
|
||||||
|
}
|
||||||
/**
|
/**
|
||||||
* Splits a string into a vector of the substrings separated by a given
|
* Splits a string into a vector of the substrings separated by a given
|
||||||
* string
|
* string
|
||||||
*/
|
*/
|
||||||
#[inline]
|
#[inline]
|
||||||
fn split_str(&self, sep: &'a str) -> ~[~str] { split_str(*self, sep) }
|
fn each_split_str(&self, sep: &'a str, it: &fn(&str) -> bool) {
|
||||||
|
each_split_str(*self, sep, it)
|
||||||
|
}
|
||||||
/// Returns true if one string starts with another
|
/// Returns true if one string starts with another
|
||||||
#[inline]
|
#[inline]
|
||||||
fn starts_with(&self, needle: &'a str) -> bool {
|
fn starts_with(&self, needle: &'a str) -> bool {
|
||||||
|
|
|
@ -120,7 +120,9 @@ pub fn get_used_libraries(cstore: @mut CStore) -> ~[~str] {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn add_used_link_args(cstore: @mut CStore, args: &str) {
|
pub fn add_used_link_args(cstore: @mut CStore, args: &str) {
|
||||||
cstore.used_link_args.push_all(args.split_char(' '));
|
for args.each_split_char(' ') |s| {
|
||||||
|
cstore.used_link_args.push(s.to_owned());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn get_used_link_args(cstore: @mut CStore) -> ~[~str] {
|
pub fn get_used_link_args(cstore: @mut CStore) -> ~[~str] {
|
||||||
|
|
|
@ -76,7 +76,7 @@ use syntax::visit::{visit_mod, visit_ty, vt};
|
||||||
use syntax::opt_vec::OptVec;
|
use syntax::opt_vec::OptVec;
|
||||||
|
|
||||||
use core::option::{Some, get, is_some, is_none};
|
use core::option::{Some, get, is_some, is_none};
|
||||||
use core::str::{connect, split_str};
|
use core::str::{connect, each_split_str};
|
||||||
use core::hashmap::linear::LinearMap;
|
use core::hashmap::linear::LinearMap;
|
||||||
use std::oldmap::HashMap;
|
use std::oldmap::HashMap;
|
||||||
|
|
||||||
|
@ -1696,7 +1696,8 @@ pub impl Resolver {
|
||||||
entry: %s (%?)",
|
entry: %s (%?)",
|
||||||
path_string, def_like);
|
path_string, def_like);
|
||||||
|
|
||||||
let mut pieces = split_str(path_string, ~"::");
|
let mut pieces = ~[];
|
||||||
|
for each_split_str(path_string, "::") |s| { pieces.push(s.to_owned()) }
|
||||||
let final_ident_str = pieces.pop();
|
let final_ident_str = pieces.pop();
|
||||||
let final_ident = self.session.ident_of(final_ident_str);
|
let final_ident = self.session.ident_of(final_ident_str);
|
||||||
|
|
||||||
|
|
|
@ -16,12 +16,16 @@ pub trait ToBase64 {
|
||||||
fn to_base64(&self) -> ~str;
|
fn to_base64(&self) -> ~str;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static CHARS: &'static[char] = &[
|
||||||
|
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
|
||||||
|
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||||||
|
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
|
||||||
|
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
|
||||||
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
|
||||||
|
];
|
||||||
|
|
||||||
impl ToBase64 for &'self [u8] {
|
impl ToBase64 for &'self [u8] {
|
||||||
fn to_base64(&self) -> ~str {
|
fn to_base64(&self) -> ~str {
|
||||||
let chars = str::chars(
|
|
||||||
~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
|
||||||
);
|
|
||||||
|
|
||||||
let mut s = ~"";
|
let mut s = ~"";
|
||||||
unsafe {
|
unsafe {
|
||||||
let len = self.len();
|
let len = self.len();
|
||||||
|
@ -35,10 +39,10 @@ impl ToBase64 for &'self [u8] {
|
||||||
(self[i + 2u] as uint);
|
(self[i + 2u] as uint);
|
||||||
|
|
||||||
// This 24-bit number gets separated into four 6-bit numbers.
|
// This 24-bit number gets separated into four 6-bit numbers.
|
||||||
str::push_char(&mut s, chars[(n >> 18u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 18u) & 63u]);
|
||||||
str::push_char(&mut s, chars[(n >> 12u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 12u) & 63u]);
|
||||||
str::push_char(&mut s, chars[(n >> 6u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 6u) & 63u]);
|
||||||
str::push_char(&mut s, chars[n & 63u]);
|
str::push_char(&mut s, CHARS[n & 63u]);
|
||||||
|
|
||||||
i += 3u;
|
i += 3u;
|
||||||
}
|
}
|
||||||
|
@ -49,17 +53,17 @@ impl ToBase64 for &'self [u8] {
|
||||||
0 => (),
|
0 => (),
|
||||||
1 => {
|
1 => {
|
||||||
let n = (self[i] as uint) << 16u;
|
let n = (self[i] as uint) << 16u;
|
||||||
str::push_char(&mut s, chars[(n >> 18u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 18u) & 63u]);
|
||||||
str::push_char(&mut s, chars[(n >> 12u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 12u) & 63u]);
|
||||||
str::push_char(&mut s, '=');
|
str::push_char(&mut s, '=');
|
||||||
str::push_char(&mut s, '=');
|
str::push_char(&mut s, '=');
|
||||||
}
|
}
|
||||||
2 => {
|
2 => {
|
||||||
let n = (self[i] as uint) << 16u |
|
let n = (self[i] as uint) << 16u |
|
||||||
(self[i + 1u] as uint) << 8u;
|
(self[i + 1u] as uint) << 8u;
|
||||||
str::push_char(&mut s, chars[(n >> 18u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 18u) & 63u]);
|
||||||
str::push_char(&mut s, chars[(n >> 12u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 12u) & 63u]);
|
||||||
str::push_char(&mut s, chars[(n >> 6u) & 63u]);
|
str::push_char(&mut s, CHARS[(n >> 6u) & 63u]);
|
||||||
str::push_char(&mut s, '=');
|
str::push_char(&mut s, '=');
|
||||||
}
|
}
|
||||||
_ => fail!(~"Algebra is broken, please alert the math police")
|
_ => fail!(~"Algebra is broken, please alert the math police")
|
||||||
|
|
|
@ -244,7 +244,8 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
|
||||||
let mut i_arg = None;
|
let mut i_arg = None;
|
||||||
if cur[1] == '-' as u8 {
|
if cur[1] == '-' as u8 {
|
||||||
let tail = str::slice(cur, 2, curlen).to_owned();
|
let tail = str::slice(cur, 2, curlen).to_owned();
|
||||||
let tail_eq = str::splitn_char(tail, '=', 1);
|
let mut tail_eq = ~[];
|
||||||
|
for str::each_splitn_char(tail, '=', 1) |s| { tail_eq.push(s.to_owned()) }
|
||||||
if tail_eq.len() <= 1 {
|
if tail_eq.len() <= 1 {
|
||||||
names = ~[Long(tail)];
|
names = ~[Long(tail)];
|
||||||
} else {
|
} else {
|
||||||
|
@ -627,16 +628,16 @@ pub mod groups {
|
||||||
};
|
};
|
||||||
|
|
||||||
// Normalize desc to contain words seperated by one space character
|
// Normalize desc to contain words seperated by one space character
|
||||||
let mut desc_normalized_whitespace = ~str
|
let mut desc_normalized_whitespace = ~"";
|
||||||
for desc.each_word |word| {
|
for str::each_word(desc) |word| {
|
||||||
desc_normalized_whitespace.push_str(word);
|
desc_normalized_whitespace.push_str(word);
|
||||||
desc_normalized_whitespace.push_char(' ');
|
desc_normalized_whitespace.push_char(' ');
|
||||||
}
|
}
|
||||||
|
|
||||||
// FIXME: #5516
|
// FIXME: #5516
|
||||||
let mut desc_rows: ~[~str] = ~[];
|
let mut desc_rows = ~[];
|
||||||
for desc_normalized_whitespace.each_split_within(54) |substr| {
|
for str::each_split_within(desc_normalized_whitespace, 54) |substr| {
|
||||||
desc_rows.push(~substr);
|
desc_rows.push(substr.to_owned());
|
||||||
}
|
}
|
||||||
|
|
||||||
// FIXME: #5516
|
// FIXME: #5516
|
||||||
|
|
|
@ -806,7 +806,8 @@ impl serialize::Decoder for Decoder<'self> {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_char(&self) -> char {
|
fn read_char(&self) -> char {
|
||||||
let v = str::chars(self.read_owned_str());
|
let mut v = ~[];
|
||||||
|
for str::each_char(self.read_owned_str()) |c| { v.push(c) }
|
||||||
if v.len() != 1 { fail!(~"string must have one character") }
|
if v.len() != 1 { fail!(~"string must have one character") }
|
||||||
v[0]
|
v[0]
|
||||||
}
|
}
|
||||||
|
|
|
@ -197,7 +197,9 @@ pub mod v4 {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
|
pub fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
|
||||||
let parts = vec::map(str::split_char(ip, '.'), |s| {
|
let mut parts = ~[];
|
||||||
|
for str::each_split_char(ip, '.') |s| { parts.push(s.to_owned()) }
|
||||||
|
let parts = vec::map(parts, |s| {
|
||||||
match uint::from_str(*s) {
|
match uint::from_str(*s) {
|
||||||
Some(n) if n <= 255 => n,
|
Some(n) if n <= 255 => n,
|
||||||
_ => 256
|
_ => 256
|
||||||
|
|
|
@ -344,8 +344,8 @@ fn userinfo_to_str(userinfo: &UserInfo) -> ~str {
|
||||||
fn query_from_str(rawquery: &str) -> Query {
|
fn query_from_str(rawquery: &str) -> Query {
|
||||||
let mut query: Query = ~[];
|
let mut query: Query = ~[];
|
||||||
if str::len(rawquery) != 0 {
|
if str::len(rawquery) != 0 {
|
||||||
for str::split_char(rawquery, '&').each |p| {
|
for str::each_split_char(rawquery, '&') |p| {
|
||||||
let (k, v) = split_char_first(*p, '=');
|
let (k, v) = split_char_first(p, '=');
|
||||||
// FIXME(#3722): unsafe only because decode_inner does (string) IO
|
// FIXME(#3722): unsafe only because decode_inner does (string) IO
|
||||||
unsafe {query.push((decode_component(k), decode_component(v)));}
|
unsafe {query.push((decode_component(k), decode_component(v)));}
|
||||||
};
|
};
|
||||||
|
|
|
@ -99,7 +99,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
|
||||||
}
|
}
|
||||||
|
|
||||||
return do lines.map |line| {
|
return do lines.map |line| {
|
||||||
let chars = str::chars(*line);
|
let mut chars = ~[];
|
||||||
|
for str::each_char(*line) |c| { chars.push(c) }
|
||||||
if i > chars.len() {
|
if i > chars.len() {
|
||||||
~""
|
~""
|
||||||
} else {
|
} else {
|
||||||
|
@ -116,7 +117,10 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
|
||||||
}
|
}
|
||||||
|
|
||||||
if comment.starts_with(~"/*") {
|
if comment.starts_with(~"/*") {
|
||||||
let lines = str::lines_any(comment.slice(3u, comment.len() - 2u).to_owned());
|
let mut lines = ~[];
|
||||||
|
for str::each_line_any(comment.slice(3u, comment.len() - 2u)) |line| {
|
||||||
|
lines.push(line.to_owned())
|
||||||
|
}
|
||||||
let lines = vertical_trim(lines);
|
let lines = vertical_trim(lines);
|
||||||
let lines = block_trim(lines, ~"\t ", None);
|
let lines = block_trim(lines, ~"\t ", None);
|
||||||
let lines = block_trim(lines, ~"*", Some(1u));
|
let lines = block_trim(lines, ~"*", Some(1u));
|
||||||
|
|
Loading…
Add table
Add a link
Reference in a new issue