mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

auto merge of #6586 : bjz/rust/formatting-and-conditionals, r=thestinger

Browse Source
This commit is contained in:
bors 2013-05-18 00:34:24 -07:00
commit e91daaa8a9
12 changed files with 284 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/libcore/bool.rs
View File

@ -49,12 +49,10 @@ pub fn is_false(v: bool) -> bool { !v }
/// Parse logic value from `s`
impl FromStr for bool {
fn from_str(s: &str) -> Option<bool> {
if s == "true" {
Some(true)
} else if s == "false" {
Some(false)
} else {
None
match s {
"true" => Some(true),
"false" => Some(false),
_ => None,
}
}
}

3
src/libcore/cmp.rs
View File

@ -127,12 +127,11 @@ totalord_impl!(uint)
totalord_impl!(char)
/// Compares (a1, b1) against (a2, b2), where the a values are more significant.
pub fn cmp2<A:TotalOrd,B:TotalOrd>(
a1: &A, b1: &B,
a2: &A, b2: &B) -> Ordering
{
//! Compares (a1, b1) against (a2, b2), where the a values are more significant.
match a1.cmp(a2) {
Less => Less,
Greater => Greater,

88
src/libcore/either.rs
View File

@ -26,26 +26,22 @@ pub enum Either<T, U> {
Right(U)
}
/// Applies a function based on the given either value
///
/// If `value` is left(T) then `f_left` is applied to its contents, if
/// `value` is right(U) then `f_right` is applied to its contents, and the
/// result is returned.
#[inline(always)]
pub fn either<T, U, V>(f_left: &fn(&T) -> V,
f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
/*!
* Applies a function based on the given either value
*
* If `value` is left(T) then `f_left` is applied to its contents, if
* `value` is right(U) then `f_right` is applied to its contents, and the
* result is returned.
*/
match *value {
Left(ref l) => f_left(l),
Right(ref r) => f_right(r)
Left(ref l) => f_left(l),
Right(ref r) => f_right(r)
}
}
/// Extracts from a vector of either all the left values
pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
//! Extracts from a vector of either all the left values
do vec::build_sized(eithers.len()) |push| {
for eithers.each |elt| {
match *elt {
@ -56,9 +52,8 @@ pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
}
}
/// Extracts from a vector of either all the right values
pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
//! Extracts from a vector of either all the right values
do vec::build_sized(eithers.len()) |push| {
for eithers.each |elt| {
match *elt {
@ -69,80 +64,73 @@ pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
}
}
pub fn partition<T, U>(eithers: ~[Either<T, U>])
-> (~[T], ~[U]) {
/*!
* Extracts from a vector of either all the left values and right values
*
* Returns a structure containing a vector of left values and a vector of
* right values.
*/
/// Extracts from a vector of either all the left values and right values
///
/// Returns a structure containing a vector of left values and a vector of
/// right values.
pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
let mut lefts: ~[T] = ~[];
let mut rights: ~[U] = ~[];
do vec::consume(eithers) |_i, elt| {
match elt {
Left(l) => lefts.push(l),
Right(r) => rights.push(r)
Left(l) => lefts.push(l),
Right(r) => rights.push(r)
}
}
return (lefts, rights);
}
/// Flips between left and right of a given either
#[inline(always)]
pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
//! Flips between left and right of a given either
match eith {
Right(r) => Left(r),
Left(l) => Right(l)
Right(r) => Left(r),
Left(l) => Right(l)
}
}
/// Converts either::t to a result::t
///
/// Converts an `either` type to a `result` type, making the "right" choice
/// an ok result, and the "left" choice a fail
#[inline(always)]
pub fn to_result<T, U>(eith: Either<T, U>)
-> Result<U, T> {
/*!
* Converts either::t to a result::t
*
* Converts an `either` type to a `result` type, making the "right" choice
* an ok result, and the "left" choice a fail
*/
pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> {
match eith {
Right(r) => result::Ok(r),
Left(l) => result::Err(l)
Right(r) => result::Ok(r),
Left(l) => result::Err(l)
}
}
/// Checks whether the given value is a left
#[inline(always)]
pub fn is_left<T, U>(eith: &Either<T, U>) -> bool {
//! Checks whether the given value is a left
match *eith { Left(_) => true, _ => false }
match *eith {
Left(_) => true,
_ => false
}
}
/// Checks whether the given value is a right
#[inline(always)]
pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
//! Checks whether the given value is a right
match *eith { Right(_) => true, _ => false }
match *eith {
Right(_) => true,
_ => false
}
}
/// Retrieves the value in the left branch. Fails if the either is Right.
#[inline(always)]
pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
//! Retrieves the value in the left branch. Fails if the either is Right.
match eith {
Left(x) => x,
Right(_) => fail!("either::unwrap_left Right")
}
}
/// Retrieves the value in the right branch. Fails if the either is Left.
#[inline(always)]
pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
//! Retrieves the value in the right branch. Fails if the either is Left.
match eith {
Right(x) => x,
Left(_) => fail!("either::unwrap_right Left")

4
src/libcore/managed.rs
View File

@ -35,16 +35,16 @@ pub mod raw {
}
/// Determine if two shared boxes point to the same object
#[inline(always)]
pub fn ptr_eq<T>(a: @T, b: @T) -> bool {
//! Determine if two shared boxes point to the same object
let a_ptr: *T = to_unsafe_ptr(&*a), b_ptr: *T = to_unsafe_ptr(&*b);
a_ptr == b_ptr
}
/// Determine if two mutable shared boxes point to the same object
#[inline(always)]
pub fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
//! Determine if two mutable shared boxes point to the same object
let a_ptr: *T = to_unsafe_ptr(&*a), b_ptr: *T = to_unsafe_ptr(&*b);
a_ptr == b_ptr
}

16
src/libcore/num/f32.rs
View File

@ -248,8 +248,7 @@ impl Orderable for f32 {
if self.is_NaN() || other.is_NaN() { Float::NaN() } else { fmax(*self, *other) }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
/// If any of the numbers are `NaN` then `NaN` is returned.
#[cfg(stage0)]
#[inline(always)]
fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
if self.is_NaN() { *self }
@ -257,6 +256,19 @@ impl Orderable for f32 {
else if !(*self >= *mn) { *mn }
else { *self }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
/// If any of the numbers are `NaN` then `NaN` is returned.
#[cfg(not(stage0))]
#[inline(always)]
fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
cond!(
(self.is_NaN()) { *self }
(!(*self <= *mx)) { *mx }
(!(*self >= *mn)) { *mn }
_ { *self }
)
}
}
impl Zero for f32 {

16
src/libcore/num/f64.rs
View File

@ -270,8 +270,7 @@ impl Orderable for f64 {
if self.is_NaN() || other.is_NaN() { Float::NaN() } else { fmax(*self, *other) }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
/// If any of the numbers are `NaN` then `NaN` is returned.
#[cfg(stage0)]
#[inline(always)]
fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
if self.is_NaN() { *self }
@ -279,6 +278,19 @@ impl Orderable for f64 {
else if !(*self >= *mn) { *mn }
else { *self }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
/// If any of the numbers are `NaN` then `NaN` is returned.
#[cfg(not(stage0))]
#[inline(always)]
fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
cond!(
(self.is_NaN()) { *self }
(!(*self <= *mx)) { *mx }
(!(*self >= *mn)) { *mn }
_ { *self }
)
}
}
impl Zero for f64 {

12
src/libcore/num/int-template.rs
View File

@ -187,11 +187,23 @@ impl Orderable for T {
if *self > *other { *self } else { *other }
}
#[cfg(stage0)]
#[inline(always)]
fn clamp(&self, mn: &T, mx: &T) -> T {
if *self > *mx { *mx } else
if *self < *mn { *mn } else { *self }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
#[cfg(not(stage0))]
#[inline(always)]
fn clamp(&self, mn: &T, mx: &T) -> T {
cond!(
(*self > *mx) { *mx }
(*self < *mn) { *mn }
_ { *self }
)
}
}
impl Zero for T {

12
src/libcore/num/uint-template.rs
View File

@ -153,11 +153,23 @@ impl Orderable for T {
if *self > *other { *self } else { *other }
}
#[cfg(stage0)]
#[inline(always)]
fn clamp(&self, mn: &T, mx: &T) -> T {
if *self > *mx { *mx } else
if *self < *mn { *mn } else { *self }
}
/// Returns the number constrained within the range `mn <= self <= mx`.
#[cfg(not(stage0))]
#[inline(always)]
fn clamp(&self, mn: &T, mx: &T) -> T {
cond!(
(*self > *mx) { *mx }
(*self < *mn) { *mn }
_ { *self }
)
}
}
impl Zero for T {

20
src/libcore/option.rs
View File

@ -89,11 +89,11 @@ impl<T:Ord> Ord for Option<T> {
}
fn ge(&self, other: &Option<T>) -> bool {
! (self < other)
!(self < other)
}
fn gt(&self, other: &Option<T>) -> bool {
! (self <= other)
!(self <= other)
}
}
@ -182,12 +182,10 @@ pub impl<T> Option<T> {
#[inline(always)]
fn is_some(&const self) -> bool { !self.is_none() }
/// Update an optional value by optionally running its content through a
/// function that returns an option.
#[inline(always)]
fn chain<U>(self, f: &fn(t: T) -> Option<U>) -> Option<U> {
/*!
* Update an optional value by optionally running its content through a
* function that returns an option.
*/
match self {
Some(t) => f(t),
@ -195,21 +193,17 @@ pub impl<T> Option<T> {
}
}
/// Returns the leftmost Some() value, or None if both are None.
#[inline(always)]
fn or(self, optb: Option<T>) -> Option<T> {
/*!
* Returns the leftmost Some() value, or None if both are None.
*/
match self {
Some(opta) => Some(opta),
_ => optb
}
}
/**
* Update an optional value by optionally running its content by reference
* through a function that returns an option.
*/
/// Update an optional value by optionally running its content by reference
/// through a function that returns an option.
#[inline(always)]
fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>) -> Option<U> {
match *self { Some(ref x) => f(x), None => None }

245
src/libcore/path.rs
View File

@ -311,9 +311,10 @@ pub impl Path {
unsafe {
do str::as_c_str(self.to_str()) |buf| {
let mut st = stat::arch::default_stat();
let r = libc::stat(buf, &mut st);
if r == 0 { Some(st) } else { None }
match libc::stat(buf, &mut st) {
0 => Some(st),
_ => None,
}
}
}
}
@ -323,9 +324,10 @@ pub impl Path {
unsafe {
do str::as_c_str(self.to_str()) |buf| {
let mut st = stat::arch::default_stat();
let r = libc::lstat(buf, &mut st);
if r == 0 { Some(st) } else { None }
match libc::lstat(buf, &mut st) {
0 => Some(st),
_ => None,
}
}
}
}
@ -450,55 +452,56 @@ impl GenericPath for PosixPath {
components.push(s.to_owned())
}
let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
return PosixPath { is_absolute: is_absolute,
components: components }
PosixPath {
is_absolute: is_absolute,
components: components,
}
}
fn dirname(&self) -> ~str {
let s = self.dir_path().to_str();
if s.len() == 0 {
~"."
} else {
s
match s.len() {
0 => ~".",
_ => s,
}
}
fn filename(&self) -> Option<~str> {
match self.components.len() {
0 => None,
n => Some(copy self.components[n - 1])
0 => None,
n => Some(copy self.components[n - 1]),
}
}
fn filestem(&self) -> Option<~str> {
match self.filename() {
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) => Some(f.slice(0, p).to_owned()),
None => Some(copy *f)
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) => Some(f.slice(0, p).to_owned()),
None => Some(copy *f),
}
}
}
}
}
fn filetype(&self) -> Option<~str> {
match self.filename() {
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
_ => None
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
_ => None,
}
}
}
}
}
fn with_dirname(&self, d: &str) -> PosixPath {
let dpath = PosixPath(d);
match self.filename() {
Some(ref f) => dpath.push(*f),
None => dpath
Some(ref f) => dpath.push(*f),
None => dpath,
}
}
@ -509,31 +512,24 @@ impl GenericPath for PosixPath {
fn with_filestem(&self, s: &str) -> PosixPath {
match self.filetype() {
None => self.with_filename(s),
Some(ref t) => self.with_filename(str::to_owned(s) + *t)
None => self.with_filename(s),
Some(ref t) => self.with_filename(str::to_owned(s) + *t),
}
}
fn with_filetype(&self, t: &str) -> PosixPath {
if t.len() == 0 {
match self.filestem() {
None => copy *self,
Some(ref s) => self.with_filename(*s)
}
} else {
let t = ~"." + str::to_owned(t);
match self.filestem() {
None => self.with_filename(t),
Some(ref s) => self.with_filename(*s + t)
}
match (t.len(), self.filestem()) {
(0, None) => copy *self,
(0, Some(ref s)) => self.with_filename(*s),
(_, None) => self.with_filename(fmt!(".%s", t)),
(_, Some(ref s)) => self.with_filename(fmt!("%s.%s", *s, t)),
}
}
fn dir_path(&self) -> PosixPath {
if self.components.len() != 0 {
self.pop()
} else {
copy *self
match self.components.len() {
0 => copy *self,
_ => self.pop(),
}
}
@ -542,8 +538,10 @@ impl GenericPath for PosixPath {
None => ~[],
Some(ref f) => ~[copy *f]
};
return PosixPath { is_absolute: false,
components: cs }
PosixPath {
is_absolute: false,
components: cs,
}
}
fn push_rel(&self, other: &PosixPath) -> PosixPath {
@ -553,8 +551,10 @@ impl GenericPath for PosixPath {
fn unsafe_join(&self, other: &PosixPath) -> PosixPath {
if other.is_absolute {
PosixPath { is_absolute: true,
components: copy other.components }
PosixPath {
is_absolute: true,
components: copy other.components,
}
} else {
self.push_rel(other)
}
@ -573,8 +573,10 @@ impl GenericPath for PosixPath {
}
v.push_all_move(ss);
}
PosixPath { is_absolute: self.is_absolute,
components: v }
PosixPath {
is_absolute: self.is_absolute,
components: v,
}
}
fn push(&self, s: &str) -> PosixPath {
@ -592,19 +594,17 @@ impl GenericPath for PosixPath {
if cs.len() != 0 {
cs.pop();
}
return PosixPath {
PosixPath {
is_absolute: self.is_absolute,
components: cs
}
//..self }
components: cs,
} //..self }
}
fn normalize(&self) -> PosixPath {
return PosixPath {
PosixPath {
is_absolute: self.is_absolute,
components: normalize(self.components)
// ..self
}
components: normalize(self.components),
} // ..self }
}
fn is_absolute(&self) -> bool {
@ -638,26 +638,25 @@ impl GenericPath for WindowsPath {
let device;
let rest;
match windows::extract_drive_prefix(s) {
Some((ref d, ref r)) => {
host = None;
device = Some(copy *d);
rest = copy *r;
}
None => {
match windows::extract_unc_prefix(s) {
Some((ref h, ref r)) => {
match (
windows::extract_drive_prefix(s),
windows::extract_unc_prefix(s),
) {
(Some((ref d, ref r)), _) => {
host = None;
device = Some(copy *d);
rest = copy *r;
}
(None, Some((ref h, ref r))) => {
host = Some(copy *h);
device = None;
rest = copy *r;
}
None => {
}
(None, None) => {
host = None;
device = None;
rest = str::to_owned(s);
}
}
}
}
let mut components = ~[];
@ -665,37 +664,38 @@ impl GenericPath for WindowsPath {
components.push(s.to_owned())
}
let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
return WindowsPath { host: host,
device: device,
is_absolute: is_absolute,
components: components }
WindowsPath {
host: host,
device: device,
is_absolute: is_absolute,
components: components,
}
}
fn dirname(&self) -> ~str {
let s = self.dir_path().to_str();
if s.len() == 0 {
~"."
} else {
s
match s.len() {
0 => ~".",
_ => s,
}
}
fn filename(&self) -> Option<~str> {
match self.components.len() {
0 => None,
n => Some(copy self.components[n - 1])
0 => None,
n => Some(copy self.components[n - 1]),
}
}
fn filestem(&self) -> Option<~str> {
match self.filename() {
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) => Some(f.slice(0, p).to_owned()),
None => Some(copy *f)
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) => Some(f.slice(0, p).to_owned()),
None => Some(copy *f),
}
}
}
}
}
@ -704,8 +704,8 @@ impl GenericPath for WindowsPath {
None => None,
Some(ref f) => {
match str::rfind_char(*f, '.') {
Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
_ => None
Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
_ => None,
}
}
}
@ -714,8 +714,8 @@ impl GenericPath for WindowsPath {
fn with_dirname(&self, d: &str) -> WindowsPath {
let dpath = WindowsPath(d);
match self.filename() {
Some(ref f) => dpath.push(*f),
None => dpath
Some(ref f) => dpath.push(*f),
None => dpath,
}
}
@ -726,44 +726,37 @@ impl GenericPath for WindowsPath {
fn with_filestem(&self, s: &str) -> WindowsPath {
match self.filetype() {
None => self.with_filename(s),
Some(ref t) => self.with_filename(str::to_owned(s) + *t)
None => self.with_filename(s),
Some(ref t) => self.with_filename(str::to_owned(s) + *t),
}
}
fn with_filetype(&self, t: &str) -> WindowsPath {
if t.len() == 0 {
match self.filestem() {
None => copy *self,
Some(ref s) => self.with_filename(*s)
}
} else {
let t = ~"." + str::to_owned(t);
match self.filestem() {
None => self.with_filename(t),
Some(ref s) =>
self.with_filename(*s + t)
}
match (t.len(), self.filestem()) {
(0, None) => copy *self,
(0, Some(ref s)) => self.with_filename(*s),
(_, None) => self.with_filename(fmt!(".%s", t)),
(_, Some(ref s)) => self.with_filename(fmt!("%s.%s", *s, t)),
}
}
fn dir_path(&self) -> WindowsPath {
if self.components.len() != 0 {
self.pop()
} else {
copy *self
match self.components.len() {
0 => copy *self,
_ => self.pop(),
}
}
fn file_path(&self) -> WindowsPath {
let cs = match self.filename() {
None => ~[],
Some(ref f) => ~[copy *f]
};
return WindowsPath { host: None,
device: None,
is_absolute: false,
components: cs }
WindowsPath {
host: None,
device: None,
is_absolute: false,
components: match self.filename() {
None => ~[],
Some(ref f) => ~[copy *f],
}
}
}
fn push_rel(&self, other: &WindowsPath) -> WindowsPath {
@ -784,7 +777,7 @@ impl GenericPath for WindowsPath {
host: Some(host),
device: copy other.device,
is_absolute: true,
components: copy other.components
components: copy other.components,
};
}
_ => {}
@ -797,7 +790,7 @@ impl GenericPath for WindowsPath {
host: None,
device: Some(device),
is_absolute: true,
components: copy other.components
components: copy other.components,
};
}
_ => {}
@ -809,7 +802,7 @@ impl GenericPath for WindowsPath {
host: copy self.host,
device: copy self.device,
is_absolute: self.is_absolute || other.is_absolute,
components: copy other.components
components: copy other.components,
}
}
@ -838,7 +831,7 @@ impl GenericPath for WindowsPath {
v.push_all_move(ss);
}
// tedious, but as-is, we can't use ..self
return WindowsPath {
WindowsPath {
host: copy self.host,
device: copy self.device,
is_absolute: self.is_absolute,
@ -853,7 +846,7 @@ impl GenericPath for WindowsPath {
ss.push(s.to_owned())
}
v.push_all_move(ss);
return WindowsPath { components: v, ..copy *self }
WindowsPath { components: v, ..copy *self }
}
fn pop(&self) -> WindowsPath {
@ -861,16 +854,16 @@ impl GenericPath for WindowsPath {
if cs.len() != 0 {
cs.pop();
}
return WindowsPath {
WindowsPath {
host: copy self.host,
device: copy self.device,
is_absolute: self.is_absolute,
components: cs
components: cs,
}
}
fn normalize(&self) -> WindowsPath {
return WindowsPath {
WindowsPath {
host: copy self.host,
device: match self.device {
None => None,

84
src/libcore/str.rs
View File

@ -128,57 +128,43 @@ pub fn push_char(s: &mut ~str, ch: char) {
let off = len;
do as_buf(*s) |buf, _len| {
let buf: *mut u8 = ::cast::transmute(buf);
if nb == 1u {
*ptr::mut_offset(buf, off) =
code as u8;
} else if nb == 2u {
*ptr::mut_offset(buf, off) =
(code >> 6u & 31u | tag_two_b) as u8;
*ptr::mut_offset(buf, off + 1u) =
(code & 63u | tag_cont) as u8;
} else if nb == 3u {
*ptr::mut_offset(buf, off) =
(code >> 12u & 15u | tag_three_b) as u8;
*ptr::mut_offset(buf, off + 1u) =
(code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) =
(code & 63u | tag_cont) as u8;
} else if nb == 4u {
*ptr::mut_offset(buf, off) =
(code >> 18u & 7u | tag_four_b) as u8;
*ptr::mut_offset(buf, off + 1u) =
(code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) =
(code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) =
(code & 63u | tag_cont) as u8;
} else if nb == 5u {
*ptr::mut_offset(buf, off) =
(code >> 24u & 3u | tag_five_b) as u8;
*ptr::mut_offset(buf, off + 1u) =
(code >> 18u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) =
(code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) =
(code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 4u) =
(code & 63u | tag_cont) as u8;
} else if nb == 6u {
*ptr::mut_offset(buf, off) =
(code >> 30u & 1u | tag_six_b) as u8;
*ptr::mut_offset(buf, off + 1u) =
(code >> 24u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) =
(code >> 18u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) =
(code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 4u) =
(code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 5u) =
(code & 63u | tag_cont) as u8;
match nb {
1u => {
*ptr::mut_offset(buf, off) = code as u8;
}
2u => {
*ptr::mut_offset(buf, off) = (code >> 6u & 31u | tag_two_b) as u8;
*ptr::mut_offset(buf, off + 1u) = (code & 63u | tag_cont) as u8;
}
3u => {
*ptr::mut_offset(buf, off) = (code >> 12u & 15u | tag_three_b) as u8;
*ptr::mut_offset(buf, off + 1u) = (code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) = (code & 63u | tag_cont) as u8;
}
4u => {
*ptr::mut_offset(buf, off) = (code >> 18u & 7u | tag_four_b) as u8;
*ptr::mut_offset(buf, off + 1u) = (code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) = (code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) = (code & 63u | tag_cont) as u8;
}
5u => {
*ptr::mut_offset(buf, off) = (code >> 24u & 3u | tag_five_b) as u8;
*ptr::mut_offset(buf, off + 1u) = (code >> 18u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) = (code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) = (code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 4u) = (code & 63u | tag_cont) as u8;
}
6u => {
*ptr::mut_offset(buf, off) = (code >> 30u & 1u | tag_six_b) as u8;
*ptr::mut_offset(buf, off + 1u) = (code >> 24u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 2u) = (code >> 18u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 3u) = (code >> 12u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 4u) = (code >> 6u & 63u | tag_cont) as u8;
*ptr::mut_offset(buf, off + 5u) = (code & 63u | tag_cont) as u8;
}
_ => {}
}
}
raw::set_len(s, new_len);
}
}

28
src/libcore/unicode.rs
View File

@ -14,6 +14,7 @@
pub mod general_category {
#[cfg(stage0)]
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use cmp::{Equal, Less, Greater};
use vec::bsearch;
@ -25,6 +26,18 @@ pub mod general_category {
}) != None
}
#[cfg(not(stage0))]
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use cmp::{Equal, Less, Greater};
use vec::bsearch;
use option::None;
(do bsearch(r) |&(lo,hi)| { cond!(
(lo <= c && c <= hi) { Equal }
(hi < c) { Less }
_ { Greater }
)}) != None
}
static Cc_table : &'static [(char,char)] = &[
('\x00', '\x1f'), ('\x7f', '\x9f')
@ -1449,8 +1462,7 @@ pub mod general_category {
}
pub mod derived_property {
#[cfg(stage0)]
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use cmp::{Equal, Less, Greater};
use vec::bsearch;
@ -1462,6 +1474,18 @@ pub mod derived_property {
}) != None
}
#[cfg(not(stage0))]
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
use cmp::{Equal, Less, Greater};
use vec::bsearch;
use option::None;
(do bsearch(r) |&(lo,hi)| { cond!(
(lo <= c && c <= hi) { Equal }
(hi < c) { Less }
_ { Greater }
)}) != None
}
static Alphabetic_table : &'static [(char,char)] = &[
('\x41', '\x5a'), ('\x61', '\x7a'),