From f4fa7c8a07a96cc9d0aae0bfc6515fb747f25341 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 29 May 2014 17:32:50 -0700 Subject: [PATCH] Register new snapshots --- src/liballoc/heap.rs | 9 +- src/libcore/failure.rs | 40 +-- src/libstd/fmt.rs | 40 --- src/libstd/lib.rs | 7 - src/libstd/reflect.rs | 439 -------------------------- src/libstd/repr.rs | 663 ---------------------------------------- src/libstd/rt/stack.rs | 31 +- src/libstd/rt/unwind.rs | 41 +-- src/snapshots.txt | 8 + 9 files changed, 13 insertions(+), 1265 deletions(-) delete mode 100644 src/libstd/reflect.rs delete mode 100644 src/libstd/repr.rs diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 8376fc578db..ba3180cefd6 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -133,14 +133,7 @@ unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 { } } -#[cfg(not(test), stage0)] -#[lang="exchange_free"] -#[inline] -unsafe fn exchange_free(ptr: *mut u8) { - deallocate(ptr, 0, 8); -} - -#[cfg(not(test), not(stage0))] +#[cfg(not(test))] #[lang="exchange_free"] #[inline] unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) { diff --git a/src/libcore/failure.rs b/src/libcore/failure.rs index a53a380d737..d4571eb3a43 100644 --- a/src/libcore/failure.rs +++ b/src/libcore/failure.rs @@ -30,12 +30,10 @@ use fmt; use intrinsics; -#[cfg(not(test), stage0)] -use str::raw::c_str_to_static_slice; #[cold] #[inline(never)] // this is the slow path, always #[lang="fail_"] -#[cfg(not(test), not(stage0))] +#[cfg(not(test))] fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! { format_args!(|args| -> () { begin_unwind(args, file, line); @@ -44,24 +42,9 @@ fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! { unsafe { intrinsics::abort() } } -#[cold] #[inline(never)] // this is the slow path, always -#[lang="fail_"] -#[cfg(not(test), stage0)] -fn fail_(expr: *u8, file: *u8, line: uint) -> ! { - unsafe { - let expr = c_str_to_static_slice(expr as *i8); - let file = c_str_to_static_slice(file as *i8); - format_args!(|args| -> () { - begin_unwind(args, file, line); - }, "{}", expr); - - intrinsics::abort() - } -} - #[cold] #[lang="fail_bounds_check"] -#[cfg(not(test), not(stage0))] +#[cfg(not(test))] fn fail_bounds_check(file: &'static str, line: uint, index: uint, len: uint) -> ! { format_args!(|args| -> () { @@ -70,28 +53,9 @@ fn fail_bounds_check(file: &'static str, line: uint, unsafe { intrinsics::abort() } } -#[cold] -#[lang="fail_bounds_check"] -#[cfg(not(test), stage0)] -fn fail_bounds_check(file: *u8, line: uint, index: uint, len: uint) -> ! { - let file = unsafe { c_str_to_static_slice(file as *i8) }; - format_args!(|args| -> () { - begin_unwind(args, file, line); - }, "index out of bounds: the len is {} but the index is {}", len, index); - unsafe { intrinsics::abort() } -} - #[cold] pub fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, line: uint) -> ! { #[allow(ctypes)] - #[cfg(stage0)] - extern { - #[link_name = "rust_begin_unwind"] - fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, - line: uint) -> !; - } - #[allow(ctypes)] - #[cfg(not(stage0))] extern { #[lang = "begin_unwind"] fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 9bca2f4248c..8dc2dd4bdb6 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -492,10 +492,6 @@ fn my_fmt_fn(args: &fmt::Arguments) { use io::Writer; use io; -#[cfg(stage0)] -use option::None; -#[cfg(stage0)] -use repr; use result::{Ok, Err}; use str::{Str, StrAllocating}; use str; @@ -524,21 +520,6 @@ fn my_fmt_fn(args: &fmt::Arguments) { #[doc(hidden)] pub use core::fmt::{secret_pointer}; -#[doc(hidden)] -#[cfg(stage0)] -pub fn secret_poly(x: &T, fmt: &mut Formatter) -> Result { - // FIXME #11938 - UFCS would make us able call the this method - // directly Poly::fmt(x, fmt). - x.fmt(fmt) -} - -/// Format trait for the `?` character -#[cfg(stage0)] -pub trait Poly { - /// Formats the value using the given formatter. - fn fmt(&self, &mut Formatter) -> Result; -} - /// The format function takes a precompiled format string and a list of /// arguments, to return the resulting formatted string. /// @@ -562,27 +543,6 @@ pub fn format(args: &Arguments) -> string::String{ str::from_utf8(output.unwrap().as_slice()).unwrap().into_string() } -#[cfg(stage0)] -impl Poly for T { - fn fmt(&self, f: &mut Formatter) -> Result { - match (f.width, f.precision) { - (None, None) => { - match repr::write_repr(f, self) { - Ok(()) => Ok(()), - Err(..) => Err(WriteError), - } - } - - // If we have a specified width for formatting, then we have to make - // this allocation of a new string - _ => { - let s = repr::repr_to_str(self); - f.pad(s.as_slice()) - } - } - } -} - impl<'a> Writer for Formatter<'a> { fn write(&mut self, b: &[u8]) -> io::IoResult<()> { match (*self).write(b) { diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b63ccbef55f..a67ed1c0b79 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -241,13 +241,6 @@ fn start(argc: int, argv: **u8) -> int { pub mod fmt; pub mod cleanup; -/* Unsupported interfaces */ - -#[unstable] -pub mod repr; -#[unstable] -pub mod reflect; - // Private APIs #[unstable] pub mod unstable; diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs deleted file mode 100644 index f21dcdf2a46..00000000000 --- a/src/libstd/reflect.rs +++ /dev/null @@ -1,439 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - -Runtime type reflection - -*/ - -#![allow(missing_doc)] - -use intrinsics::{Disr, Opaque, TyDesc, TyVisitor}; -use mem; -use owned::Box; - -/** - * Trait for visitor that wishes to reflect on data. To use this, create a - * struct that encapsulates the set of pointers you wish to walk through a - * data structure, and implement both `MovePtr` for it as well as `TyVisitor`; - * then build a MovePtrAdaptor wrapped around your struct. - */ -pub trait MovePtr { - fn move_ptr(&mut self, adjustment: |*u8| -> *u8); - fn push_ptr(&mut self); - fn pop_ptr(&mut self); -} - -/// Helper function for alignment calculation. -#[inline] -pub fn align(size: uint, align: uint) -> uint { - ((size + align) - 1u) & !(align - 1u) -} - -/// Adaptor to wrap around visitors implementing MovePtr. -pub struct MovePtrAdaptor { - inner: V -} - -impl MovePtrAdaptor { - pub fn new(v: V) -> MovePtrAdaptor { - MovePtrAdaptor { inner: v } - } - - #[inline] - pub fn bump(&mut self, sz: uint) { - self.inner.move_ptr(|p| ((p as uint) + sz) as *u8) - } - - #[inline] - pub fn align(&mut self, a: uint) { - self.inner.move_ptr(|p| align(p as uint, a) as *u8) - } - - #[inline] - pub fn align_to(&mut self) { - self.align(mem::min_align_of::()); - } - - #[inline] - pub fn bump_past(&mut self) { - self.bump(mem::size_of::()); - } - - pub fn unwrap(self) -> V { self.inner } -} - -/// Abstract type-directed pointer-movement using the MovePtr trait -impl TyVisitor for MovePtrAdaptor { - fn visit_bot(&mut self) -> bool { - self.align_to::<()>(); - if ! self.inner.visit_bot() { return false; } - self.bump_past::<()>(); - true - } - - fn visit_nil(&mut self) -> bool { - self.align_to::<()>(); - if ! self.inner.visit_nil() { return false; } - self.bump_past::<()>(); - true - } - - fn visit_bool(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_bool() { return false; } - self.bump_past::(); - true - } - - fn visit_int(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_int() { return false; } - self.bump_past::(); - true - } - - fn visit_i8(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_i8() { return false; } - self.bump_past::(); - true - } - - fn visit_i16(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_i16() { return false; } - self.bump_past::(); - true - } - - fn visit_i32(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_i32() { return false; } - self.bump_past::(); - true - } - - fn visit_i64(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_i64() { return false; } - self.bump_past::(); - true - } - - fn visit_uint(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_uint() { return false; } - self.bump_past::(); - true - } - - fn visit_u8(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_u8() { return false; } - self.bump_past::(); - true - } - - fn visit_u16(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_u16() { return false; } - self.bump_past::(); - true - } - - fn visit_u32(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_u32() { return false; } - self.bump_past::(); - true - } - - fn visit_u64(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_u64() { return false; } - self.bump_past::(); - true - } - - fn visit_f32(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_f32() { return false; } - self.bump_past::(); - true - } - - fn visit_f64(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_f64() { return false; } - self.bump_past::(); - true - } - - fn visit_f128(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_f128() { return false; } - self.bump_past::(); - true - } - - fn visit_char(&mut self) -> bool { - self.align_to::(); - if ! self.inner.visit_char() { return false; } - self.bump_past::(); - true - } - - fn visit_estr_box(&mut self) -> bool { - true - } - - fn visit_estr_uniq(&mut self) -> bool { - self.align_to::<~str>(); - if ! self.inner.visit_estr_uniq() { return false; } - self.bump_past::<~str>(); - true - } - - fn visit_estr_slice(&mut self) -> bool { - self.align_to::<&'static str>(); - if ! self.inner.visit_estr_slice() { return false; } - self.bump_past::<&'static str>(); - true - } - - fn visit_estr_fixed(&mut self, n: uint, - sz: uint, - align: uint) -> bool { - self.align(align); - if ! self.inner.visit_estr_fixed(n, sz, align) { return false; } - self.bump(sz); - true - } - - fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::<@u8>(); - if ! self.inner.visit_box(mtbl, inner) { return false; } - self.bump_past::<@u8>(); - true - } - - fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::>(); - if ! self.inner.visit_uniq(mtbl, inner) { return false; } - self.bump_past::>(); - true - } - - fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::<*u8>(); - if ! self.inner.visit_ptr(mtbl, inner) { return false; } - self.bump_past::<*u8>(); - true - } - - fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::<&'static u8>(); - if ! self.inner.visit_rptr(mtbl, inner) { return false; } - self.bump_past::<&'static u8>(); - true - } - - fn visit_evec_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { - true - } - - fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::<~[u8]>(); - if ! self.inner.visit_evec_uniq(mtbl, inner) { return false; } - self.bump_past::<~[u8]>(); - true - } - - fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.align_to::<&'static [u8]>(); - if ! self.inner.visit_evec_slice(mtbl, inner) { return false; } - self.bump_past::<&'static [u8]>(); - true - } - - fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, - mtbl: uint, inner: *TyDesc) -> bool { - self.align(align); - if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) { - return false; - } - self.bump(sz); - true - } - - fn visit_enter_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool { - self.align(align); - if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; } - true - } - - fn visit_rec_field(&mut self, i: uint, name: &str, - mtbl: uint, inner: *TyDesc) -> bool { - unsafe { self.align((*inner).align); } - if ! self.inner.visit_rec_field(i, name, mtbl, inner) { - return false; - } - unsafe { self.bump((*inner).size); } - true - } - - fn visit_leave_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool { - if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; } - true - } - - fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint, - align: uint) -> bool { - self.align(align); - if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) { - return false; - } - true - } - - fn visit_class_field(&mut self, i: uint, name: &str, named: bool, mtbl: uint, - inner: *TyDesc) -> bool { - unsafe { self.align((*inner).align); } - if ! self.inner.visit_class_field(i, name, named, mtbl, inner) { - return false; - } - unsafe { self.bump((*inner).size); } - true - } - - fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint, - align: uint) -> bool { - if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) { - return false; - } - true - } - - fn visit_enter_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool { - self.align(align); - if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; } - true - } - - fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool { - unsafe { self.align((*inner).align); } - if ! self.inner.visit_tup_field(i, inner) { return false; } - unsafe { self.bump((*inner).size); } - true - } - - fn visit_leave_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool { - if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; } - true - } - - fn visit_enter_fn(&mut self, purity: uint, proto: uint, - n_inputs: uint, retstyle: uint) -> bool { - if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) { - return false - } - true - } - - fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool { - if ! self.inner.visit_fn_input(i, mode, inner) { return false; } - true - } - - fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool { - if ! self.inner.visit_fn_output(retstyle, variadic, inner) { return false; } - true - } - - fn visit_leave_fn(&mut self, purity: uint, proto: uint, - n_inputs: uint, retstyle: uint) -> bool { - if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) { - return false; - } - true - } - - fn visit_enter_enum(&mut self, n_variants: uint, - get_disr: unsafe extern fn(ptr: *Opaque) -> Disr, - sz: uint, align: uint) - -> bool { - self.align(align); - if ! self.inner.visit_enter_enum(n_variants, get_disr, sz, align) { - return false; - } - true - } - - fn visit_enter_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool { - if ! self.inner.visit_enter_enum_variant(variant, disr_val, - n_fields, name) { - return false; - } - true - } - - fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool { - self.inner.push_ptr(); - self.bump(offset); - if ! self.inner.visit_enum_variant_field(i, offset, inner) { return false; } - self.inner.pop_ptr(); - true - } - - fn visit_leave_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool { - if ! self.inner.visit_leave_enum_variant(variant, disr_val, - n_fields, name) { - return false; - } - true - } - - fn visit_leave_enum(&mut self, n_variants: uint, - get_disr: unsafe extern fn(ptr: *Opaque) -> Disr, - sz: uint, align: uint) -> bool { - if ! self.inner.visit_leave_enum(n_variants, get_disr, sz, align) { - return false; - } - self.bump(sz); - true - } - - fn visit_trait(&mut self, name: &str) -> bool { - self.align_to::>(); - if ! self.inner.visit_trait(name) { return false; } - self.bump_past::>(); - true - } - - fn visit_param(&mut self, i: uint) -> bool { - if ! self.inner.visit_param(i) { return false; } - true - } - - fn visit_self(&mut self) -> bool { - self.align_to::<&'static u8>(); - if ! self.inner.visit_self() { return false; } - self.align_to::<&'static u8>(); - true - } -} diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs deleted file mode 100644 index 0621cbf35fe..00000000000 --- a/src/libstd/repr.rs +++ /dev/null @@ -1,663 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - -More runtime type reflection - -*/ - -#![allow(missing_doc)] - -use char; -use container::Container; -use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; -use io; -use iter::Iterator; -use mem::transmute; -use option::{Some, None, Option}; -use ptr::RawPtr; -use raw; -use reflect::{MovePtr, align}; -use reflect; -use result::{Ok, Err}; -use slice::Vector; -use str::{Str, StrSlice}; -use string::String; -use to_str::ToStr; -use vec::Vec; - -macro_rules! try( ($me:expr, $e:expr) => ( - match $e { - Ok(()) => {}, - Err(e) => { $me.last_err = Some(e); return false; } - } -) ) - -/// Representations - -trait Repr { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()>; -} - -impl Repr for () { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> { - writer.write("()".as_bytes()) - } -} - -impl Repr for bool { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> { - let s = if *self { "true" } else { "false" }; - writer.write(s.as_bytes()) - } -} - -impl Repr for int { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> { - write!(writer, "{}", *self) - } -} - -macro_rules! int_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> { - write!(writer, "{}{}", *self, $suffix) - } -})) - -int_repr!(i8, "i8") -int_repr!(i16, "i16") -int_repr!(i32, "i32") -int_repr!(i64, "i64") -int_repr!(uint, "u") -int_repr!(u8, "u8") -int_repr!(u16, "u16") -int_repr!(u32, "u32") -int_repr!(u64, "u64") - -macro_rules! num_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty { - fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()> { - let s = self.to_str(); - writer.write(s.as_bytes()).and_then(|()| { - writer.write(bytes!($suffix)) - }) - } -})) - -num_repr!(f32, "f32") -num_repr!(f64, "f64") - -// New implementation using reflect::MovePtr - -enum VariantState { - SearchingFor(Disr), - Matched, - AlreadyFound -} - -pub struct ReprVisitor<'a> { - ptr: *u8, - ptr_stk: Vec<*u8>, - var_stk: Vec, - writer: &'a mut io::Writer, - last_err: Option, -} - -impl<'a> MovePtr for ReprVisitor<'a> { - #[inline] - fn move_ptr(&mut self, adjustment: |*u8| -> *u8) { - self.ptr = adjustment(self.ptr); - } - fn push_ptr(&mut self) { - self.ptr_stk.push(self.ptr); - } - fn pop_ptr(&mut self) { - self.ptr = self.ptr_stk.pop().unwrap(); - } -} - -impl<'a> ReprVisitor<'a> { - // Various helpers for the TyVisitor impl - pub fn new(ptr: *u8, writer: &'a mut io::Writer) -> ReprVisitor<'a> { - ReprVisitor { - ptr: ptr, - ptr_stk: vec!(), - var_stk: vec!(), - writer: writer, - last_err: None, - } - } - - #[inline] - pub fn get(&mut self, f: |&mut ReprVisitor, &T| -> bool) -> bool { - unsafe { - f(self, transmute::<*u8,&T>(self.ptr)) - } - } - - #[inline] - pub fn visit_inner(&mut self, inner: *TyDesc) -> bool { - self.visit_ptr_inner(self.ptr, inner) - } - - #[inline] - pub fn visit_ptr_inner(&mut self, ptr: *u8, inner: *TyDesc) -> bool { - unsafe { - let u = ReprVisitor::new(ptr, ::mem::transmute_copy(&self.writer)); - let mut v = reflect::MovePtrAdaptor::new(u); - // Obviously this should not be a thing, but blame #8401 for now - visit_tydesc(inner, &mut v as &mut TyVisitor); - match v.unwrap().last_err { - Some(e) => { - self.last_err = Some(e); - false - } - None => true, - } - } - } - - #[inline] - pub fn write(&mut self) -> bool { - self.get(|this, v:&T| { - try!(this, v.write_repr(this.writer)); - true - }) - } - - pub fn write_escaped_slice(&mut self, slice: &str) -> bool { - try!(self, self.writer.write(['"' as u8])); - for ch in slice.chars() { - if !self.write_escaped_char(ch, true) { return false } - } - try!(self, self.writer.write(['"' as u8])); - true - } - - pub fn write_mut_qualifier(&mut self, mtbl: uint) -> bool { - if mtbl == 0 { - try!(self, self.writer.write("mut ".as_bytes())); - } else if mtbl == 1 { - // skip, this is ast::m_imm - } else { - fail!("invalid mutability value"); - } - true - } - - pub fn write_vec_range(&mut self, ptr: *(), len: uint, inner: *TyDesc) -> bool { - let mut p = ptr as *u8; - let (sz, al) = unsafe { ((*inner).size, (*inner).align) }; - try!(self, self.writer.write(['[' as u8])); - let mut first = true; - let mut left = len; - // unit structs have 0 size, and don't loop forever. - let dec = if sz == 0 {1} else {sz}; - while left > 0 { - if first { - first = false; - } else { - try!(self, self.writer.write(", ".as_bytes())); - } - self.visit_ptr_inner(p as *u8, inner); - p = align(unsafe { p.offset(sz as int) as uint }, al) as *u8; - left -= dec; - } - try!(self, self.writer.write([']' as u8])); - true - } - - pub fn write_unboxed_vec_repr(&mut self, _: uint, v: &raw::Vec<()>, inner: *TyDesc) -> bool { - self.write_vec_range(&v.data, v.fill, inner) - } - - fn write_escaped_char(&mut self, ch: char, is_str: bool) -> bool { - try!(self, match ch { - '\t' => self.writer.write("\\t".as_bytes()), - '\r' => self.writer.write("\\r".as_bytes()), - '\n' => self.writer.write("\\n".as_bytes()), - '\\' => self.writer.write("\\\\".as_bytes()), - '\'' => { - if is_str { - self.writer.write("'".as_bytes()) - } else { - self.writer.write("\\'".as_bytes()) - } - } - '"' => { - if is_str { - self.writer.write("\\\"".as_bytes()) - } else { - self.writer.write("\"".as_bytes()) - } - } - '\x20'..'\x7e' => self.writer.write([ch as u8]), - _ => { - char::escape_unicode(ch, |c| { - let _ = self.writer.write([c as u8]); - }); - Ok(()) - } - }); - return true; - } -} - -impl<'a> TyVisitor for ReprVisitor<'a> { - fn visit_bot(&mut self) -> bool { - try!(self, self.writer.write("!".as_bytes())); - true - } - fn visit_nil(&mut self) -> bool { self.write::<()>() } - fn visit_bool(&mut self) -> bool { self.write::() } - fn visit_int(&mut self) -> bool { self.write::() } - fn visit_i8(&mut self) -> bool { self.write::() } - fn visit_i16(&mut self) -> bool { self.write::() } - fn visit_i32(&mut self) -> bool { self.write::() } - fn visit_i64(&mut self) -> bool { self.write::() } - - fn visit_uint(&mut self) -> bool { self.write::() } - fn visit_u8(&mut self) -> bool { self.write::() } - fn visit_u16(&mut self) -> bool { self.write::() } - fn visit_u32(&mut self) -> bool { self.write::() } - fn visit_u64(&mut self) -> bool { self.write::() } - - fn visit_f32(&mut self) -> bool { self.write::() } - fn visit_f64(&mut self) -> bool { self.write::() } - fn visit_f128(&mut self) -> bool { fail!("not implemented") } - - fn visit_char(&mut self) -> bool { - self.get::(|this, &ch| { - try!(this, this.writer.write(['\'' as u8])); - if !this.write_escaped_char(ch, false) { return false } - try!(this, this.writer.write(['\'' as u8])); - true - }) - } - - fn visit_estr_box(&mut self) -> bool { - true - } - - fn visit_estr_uniq(&mut self) -> bool { - true - } - - fn visit_estr_slice(&mut self) -> bool { - self.get::<&str>(|this, s| this.write_escaped_slice(*s)) - } - - // Type no longer exists, vestigial function. - fn visit_estr_fixed(&mut self, _n: uint, _sz: uint, - _align: uint) -> bool { fail!(); } - - fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - try!(self, self.writer.write(['@' as u8])); - self.write_mut_qualifier(mtbl); - self.get::<&raw::Box<()>>(|this, b| { - let p = &b.data as *() as *u8; - this.visit_ptr_inner(p, inner) - }) - } - - fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool { - try!(self, self.writer.write("box ".as_bytes())); - self.get::<*u8>(|this, b| { - this.visit_ptr_inner(*b, inner) - }) - } - - fn visit_ptr(&mut self, mtbl: uint, _inner: *TyDesc) -> bool { - self.get::<*u8>(|this, p| { - try!(this, write!(this.writer, "({} as *", *p)); - this.write_mut_qualifier(mtbl); - try!(this, this.writer.write("())".as_bytes())); - true - }) - } - - fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - try!(self, self.writer.write(['&' as u8])); - self.write_mut_qualifier(mtbl); - self.get::<*u8>(|this, p| { - this.visit_ptr_inner(*p, inner) - }) - } - - fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.get::<&raw::Box>>(|this, b| { - try!(this, this.writer.write(['@' as u8])); - this.write_mut_qualifier(mtbl); - this.write_unboxed_vec_repr(mtbl, &b.data, inner) - }) - } - - fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.get::<&raw::Vec<()>>(|this, b| { - try!(this, this.writer.write("box ".as_bytes())); - this.write_unboxed_vec_repr(mtbl, *b, inner) - }) - } - - fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - self.get::>(|this, s| { - try!(this, this.writer.write(['&' as u8])); - this.write_mut_qualifier(mtbl); - let size = unsafe { - if (*inner).size == 0 { 1 } else { (*inner).size } - }; - this.write_vec_range(s.data, s.len * size, inner) - }) - } - - fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint, - _: uint, inner: *TyDesc) -> bool { - let assumed_size = if sz == 0 { n } else { sz }; - self.get::<()>(|this, b| { - this.write_vec_range(b, assumed_size, inner) - }) - } - - fn visit_enter_rec(&mut self, _n_fields: uint, - _sz: uint, _align: uint) -> bool { - try!(self, self.writer.write(['{' as u8])); - true - } - - fn visit_rec_field(&mut self, i: uint, name: &str, - mtbl: uint, inner: *TyDesc) -> bool { - if i != 0 { - try!(self, self.writer.write(", ".as_bytes())); - } - self.write_mut_qualifier(mtbl); - try!(self, self.writer.write(name.as_bytes())); - try!(self, self.writer.write(": ".as_bytes())); - self.visit_inner(inner); - true - } - - fn visit_leave_rec(&mut self, _n_fields: uint, - _sz: uint, _align: uint) -> bool { - try!(self, self.writer.write(['}' as u8])); - true - } - - fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, - _sz: uint, _align: uint) -> bool { - try!(self, self.writer.write(name.as_bytes())); - if n_fields != 0 { - if named_fields { - try!(self, self.writer.write(['{' as u8])); - } else { - try!(self, self.writer.write(['(' as u8])); - } - } - true - } - - fn visit_class_field(&mut self, i: uint, name: &str, named: bool, - _mtbl: uint, inner: *TyDesc) -> bool { - if i != 0 { - try!(self, self.writer.write(", ".as_bytes())); - } - if named { - try!(self, self.writer.write(name.as_bytes())); - try!(self, self.writer.write(": ".as_bytes())); - } - self.visit_inner(inner); - true - } - - fn visit_leave_class(&mut self, _name: &str, named_fields: bool, n_fields: uint, - _sz: uint, _align: uint) -> bool { - if n_fields != 0 { - if named_fields { - try!(self, self.writer.write(['}' as u8])); - } else { - try!(self, self.writer.write([')' as u8])); - } - } - true - } - - fn visit_enter_tup(&mut self, _n_fields: uint, - _sz: uint, _align: uint) -> bool { - try!(self, self.writer.write(['(' as u8])); - true - } - - fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool { - if i != 0 { - try!(self, self.writer.write(", ".as_bytes())); - } - self.visit_inner(inner); - true - } - - fn visit_leave_tup(&mut self, _n_fields: uint, - _sz: uint, _align: uint) -> bool { - if _n_fields == 1 { - try!(self, self.writer.write([',' as u8])); - } - try!(self, self.writer.write([')' as u8])); - true - } - - fn visit_enter_enum(&mut self, - _n_variants: uint, - get_disr: unsafe extern fn(ptr: *Opaque) -> Disr, - _sz: uint, - _align: uint) -> bool { - let disr = unsafe { - get_disr(transmute(self.ptr)) - }; - self.var_stk.push(SearchingFor(disr)); - true - } - - fn visit_enter_enum_variant(&mut self, _variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool { - let mut write = false; - match self.var_stk.pop().unwrap() { - SearchingFor(sought) => { - if disr_val == sought { - self.var_stk.push(Matched); - write = true; - } else { - self.var_stk.push(SearchingFor(sought)); - } - } - Matched | AlreadyFound => { - self.var_stk.push(AlreadyFound); - } - } - - if write { - try!(self, self.writer.write(name.as_bytes())); - if n_fields > 0 { - try!(self, self.writer.write(['(' as u8])); - } - } - true - } - - fn visit_enum_variant_field(&mut self, - i: uint, - _offset: uint, - inner: *TyDesc) - -> bool { - match *self.var_stk.get(self.var_stk.len() - 1) { - Matched => { - if i != 0 { - try!(self, self.writer.write(", ".as_bytes())); - } - if ! self.visit_inner(inner) { - return false; - } - } - _ => () - } - true - } - - fn visit_leave_enum_variant(&mut self, _variant: uint, - _disr_val: Disr, - n_fields: uint, - _name: &str) -> bool { - match *self.var_stk.get(self.var_stk.len() - 1) { - Matched => { - if n_fields > 0 { - try!(self, self.writer.write([')' as u8])); - } - } - _ => () - } - true - } - - fn visit_leave_enum(&mut self, - _n_variants: uint, - _get_disr: unsafe extern fn(ptr: *Opaque) -> Disr, - _sz: uint, - _align: uint) - -> bool { - match self.var_stk.pop().unwrap() { - SearchingFor(..) => fail!("enum value matched no variant"), - _ => true - } - } - - fn visit_enter_fn(&mut self, _purity: uint, _proto: uint, - _n_inputs: uint, _retstyle: uint) -> bool { - try!(self, self.writer.write("fn(".as_bytes())); - true - } - - fn visit_fn_input(&mut self, i: uint, _mode: uint, inner: *TyDesc) -> bool { - if i != 0 { - try!(self, self.writer.write(", ".as_bytes())); - } - let name = unsafe { (*inner).name }; - try!(self, self.writer.write(name.as_bytes())); - true - } - - fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool, - inner: *TyDesc) -> bool { - if variadic { - try!(self, self.writer.write(", ...".as_bytes())); - } - try!(self, self.writer.write(")".as_bytes())); - let name = unsafe { (*inner).name }; - if name != "()" { - try!(self, self.writer.write(" -> ".as_bytes())); - try!(self, self.writer.write(name.as_bytes())); - } - true - } - - fn visit_leave_fn(&mut self, _purity: uint, _proto: uint, - _n_inputs: uint, _retstyle: uint) -> bool { true } - - - fn visit_trait(&mut self, name: &str) -> bool { - try!(self, self.writer.write(name.as_bytes())); - true - } - - fn visit_param(&mut self, _i: uint) -> bool { true } - fn visit_self(&mut self) -> bool { true } -} - -pub fn write_repr(writer: &mut io::Writer, object: &T) -> io::IoResult<()> { - unsafe { - let ptr = object as *T as *u8; - let tydesc = get_tydesc::(); - let u = ReprVisitor::new(ptr, writer); - let mut v = reflect::MovePtrAdaptor::new(u); - visit_tydesc(tydesc, &mut v as &mut TyVisitor); - match v.unwrap().last_err { - Some(e) => Err(e), - None => Ok(()), - } - } -} - -pub fn repr_to_str(t: &T) -> String { - use str; - use str::StrAllocating; - use io; - - let mut result = io::MemWriter::new(); - write_repr(&mut result as &mut io::Writer, t).unwrap(); - str::from_utf8(result.unwrap().as_slice()).unwrap().to_string() -} - -#[cfg(test)] -struct P {a: int, b: f64} - -#[test] -fn test_repr() { - use prelude::*; - use str; - use str::Str; - use io::stdio::println; - use char::is_alphabetic; - use mem::swap; - - fn exact_test(t: &T, e:&str) { - let mut m = io::MemWriter::new(); - write_repr(&mut m as &mut io::Writer, t).unwrap(); - let s = str::from_utf8(m.unwrap().as_slice()).unwrap().to_owned(); - assert_eq!(s.as_slice(), e); - } - - exact_test(&10, "10"); - exact_test(&true, "true"); - exact_test(&false, "false"); - exact_test(&1.234, "1.234f64"); - exact_test(&("hello"), "\"hello\""); - - exact_test(&(@10), "@10"); - exact_test(&(box 10), "box 10"); - exact_test(&(&10), "&10"); - let mut x = 10; - exact_test(&(&mut x), "&mut 10"); - - exact_test(&(0 as *()), "(0x0 as *())"); - exact_test(&(0 as *mut ()), "(0x0 as *mut ())"); - - exact_test(&(1,), "(1,)"); - exact_test(&(&["hi", "there"]), - "&[\"hi\", \"there\"]"); - exact_test(&(P{a:10, b:1.234}), - "repr::P{a: 10, b: 1.234f64}"); - exact_test(&(@P{a:10, b:1.234}), - "@repr::P{a: 10, b: 1.234f64}"); - exact_test(&(box P{a:10, b:1.234}), - "box repr::P{a: 10, b: 1.234f64}"); - - exact_test(&(&[1, 2]), "&[1, 2]"); - exact_test(&(&mut [1, 2]), "&mut [1, 2]"); - - exact_test(&'\'', "'\\''"); - exact_test(&'"', "'\"'"); - exact_test(&("'"), "\"'\""); - exact_test(&("\""), "\"\\\"\""); - - exact_test(&println, "fn(&str)"); - exact_test(&swap::, "fn(&mut int, &mut int)"); - exact_test(&is_alphabetic, "fn(char) -> bool"); - - struct Bar(int, int); - exact_test(&(Bar(2, 2)), "repr::test_repr::Bar(2, 2)"); -} diff --git a/src/libstd/rt/stack.rs b/src/libstd/rt/stack.rs index b3be742e1ed..dc6ab494d64 100644 --- a/src/libstd/rt/stack.rs +++ b/src/libstd/rt/stack.rs @@ -30,7 +30,7 @@ /// stacks are currently not enabled as segmented stacks, but rather one giant /// stack segment. This means that whenever we run out of stack, we want to /// truly consider it to be stack overflow rather than allocating a new stack. -#[cfg(not(test), not(stage0))] // in testing, use the original libstd's version +#[cfg(not(test))] // in testing, use the original libstd's version #[lang = "stack_exhausted"] extern fn stack_exhausted() { use option::{Option, None, Some}; @@ -103,35 +103,6 @@ } } -#[no_mangle] // - this is called from C code -#[no_split_stack] // - it would be sad for this function to trigger __morestack -#[doc(hidden)] // - Function must be `pub` to get exported, but it's - // irrelevant for documentation purposes. -#[cfg(stage0, not(test))] // in testing, use the original libstd's version -pub extern "C" fn rust_stack_exhausted() { - use option::{Option, None, Some}; - use owned::Box; - use rt::local::Local; - use rt::task::Task; - use str::Str; - use intrinsics; - - unsafe { - let limit = get_sp_limit(); - record_sp_limit(limit - RED_ZONE / 2); - let task: Option> = Local::try_take(); - let name = match task { - Some(ref task) => { - task.name.as_ref().map(|n| n.as_slice()) - } - None => None - }; - let name = name.unwrap_or(""); - rterrln!("task '{}' has overflowed its stack", name); - intrinsics::abort(); - } -} - #[inline(always)] pub unsafe fn record_stack_bounds(stack_lo: uint, stack_hi: uint) { // When the old runtime had segmented stacks, it used a calculation that was diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index f34dcaaa427..dc2646102d2 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -213,7 +213,6 @@ fn __gcc_personality_v0(version: c_int, } #[lang="eh_personality"] - #[cfg(not(stage0))] extern fn eh_personality( version: c_int, actions: uw::_Unwind_Action, @@ -227,22 +226,6 @@ fn __gcc_personality_v0(version: c_int, context) } } - #[lang="eh_personality"] - #[no_mangle] // so we can reference it by name from middle/trans/base.rs - #[cfg(stage0)] - pub extern "C" fn rust_eh_personality( - version: c_int, - actions: uw::_Unwind_Action, - exception_class: uw::_Unwind_Exception_Class, - ue_header: *uw::_Unwind_Exception, - context: *uw::_Unwind_Context - ) -> uw::_Unwind_Reason_Code - { - unsafe { - __gcc_personality_v0(version, actions, exception_class, ue_header, - context) - } - } #[no_mangle] // referenced from rust_try.ll pub extern "C" fn rust_eh_personality_catch( @@ -281,7 +264,6 @@ fn __gcc_personality_v0(state: uw::_Unwind_State, } #[lang="eh_personality"] - #[cfg(not(stage0))] extern "C" fn eh_personality( state: uw::_Unwind_State, ue_header: *uw::_Unwind_Exception, @@ -293,20 +275,6 @@ extern "C" fn eh_personality( } } - #[lang="eh_personality"] - #[no_mangle] // so we can reference it by name from middle/trans/base.rs - #[cfg(stage0)] - pub extern "C" fn rust_eh_personality( - state: uw::_Unwind_State, - ue_header: *uw::_Unwind_Exception, - context: *uw::_Unwind_Context - ) -> uw::_Unwind_Reason_Code - { - unsafe { - __gcc_personality_v0(state, ue_header, context) - } - } - #[no_mangle] // referenced from rust_try.ll pub extern "C" fn rust_eh_personality_catch( state: uw::_Unwind_State, @@ -327,20 +295,13 @@ pub extern "C" fn rust_eh_personality_catch( } // Entry point of failure from the libcore crate -#[cfg(not(test), not(stage0))] +#[cfg(not(test))] #[lang = "begin_unwind"] pub extern fn rust_begin_unwind(msg: &fmt::Arguments, file: &'static str, line: uint) -> ! { begin_unwind_fmt(msg, file, line) } -#[no_mangle] -#[cfg(not(test), stage0)] -pub extern fn rust_begin_unwind(msg: &fmt::Arguments, - file: &'static str, line: uint) -> ! { - begin_unwind_fmt(msg, file, line) -} - /// The entry point for unwinding with a formatted message. /// /// This is designed to reduce the amount of code required at the call diff --git a/src/snapshots.txt b/src/snapshots.txt index 045fceef692..15c1405c4ce 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,11 @@ +S 2014-05-29 50b8528 + freebsd-x86_64 cfa0dcc98a57f03a53bb53df6fd5db02143e2bee + linux-i386 baf7c6ab5792f3d560a0f2adc94d7ff96d0cab3d + linux-x86_64 ed97bc90842b96b95e860b9d21fe1ade3f682fd3 + macos-i386 2d0e27f72e34be53b1f16d704e9a3b8bedbdbd31 + macos-x86_64 f8912b07014c234ae2d625d6da84c752508a2b04 + winnt-i386 0af7b426f57015d8392e00ee9a9d1f2f5eb10761 + S 2014-05-16 5327218 freebsd-x86_64 e91e235c808eb7e8a1e82f7e00c874de9b1df345 linux-i386 3a3b7d68ed42a144fa06c9a49c63966da9adeef2 -- GitLab