}
}
-#[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) {
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);
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| -> () {
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,
use io::Writer;
use io;
-#[cfg(stage0)]
-use option::None;
-#[cfg(stage0)]
-use repr;
use result::{Ok, Err};
use str::{Str, StrAllocating};
use str;
#[doc(hidden)]
pub use core::fmt::{secret_pointer};
-#[doc(hidden)]
-#[cfg(stage0)]
-pub fn secret_poly<T: 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.
///
str::from_utf8(output.unwrap().as_slice()).unwrap().into_string()
}
-#[cfg(stage0)]
-impl<T> 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) {
pub mod fmt;
pub mod cleanup;
-/* Unsupported interfaces */
-
-#[unstable]
-pub mod repr;
-#[unstable]
-pub mod reflect;
-
// Private APIs
#[unstable]
pub mod unstable;
+++ /dev/null
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<V> {
- inner: V
-}
-
-impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> {
- pub fn new(v: V) -> MovePtrAdaptor<V> {
- 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<T>(&mut self) {
- self.align(mem::min_align_of::<T>());
- }
-
- #[inline]
- pub fn bump_past<T>(&mut self) {
- self.bump(mem::size_of::<T>());
- }
-
- pub fn unwrap(self) -> V { self.inner }
-}
-
-/// Abstract type-directed pointer-movement using the MovePtr trait
-impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
- 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::<bool>();
- if ! self.inner.visit_bool() { return false; }
- self.bump_past::<bool>();
- true
- }
-
- fn visit_int(&mut self) -> bool {
- self.align_to::<int>();
- if ! self.inner.visit_int() { return false; }
- self.bump_past::<int>();
- true
- }
-
- fn visit_i8(&mut self) -> bool {
- self.align_to::<i8>();
- if ! self.inner.visit_i8() { return false; }
- self.bump_past::<i8>();
- true
- }
-
- fn visit_i16(&mut self) -> bool {
- self.align_to::<i16>();
- if ! self.inner.visit_i16() { return false; }
- self.bump_past::<i16>();
- true
- }
-
- fn visit_i32(&mut self) -> bool {
- self.align_to::<i32>();
- if ! self.inner.visit_i32() { return false; }
- self.bump_past::<i32>();
- true
- }
-
- fn visit_i64(&mut self) -> bool {
- self.align_to::<i64>();
- if ! self.inner.visit_i64() { return false; }
- self.bump_past::<i64>();
- true
- }
-
- fn visit_uint(&mut self) -> bool {
- self.align_to::<uint>();
- if ! self.inner.visit_uint() { return false; }
- self.bump_past::<uint>();
- true
- }
-
- fn visit_u8(&mut self) -> bool {
- self.align_to::<u8>();
- if ! self.inner.visit_u8() { return false; }
- self.bump_past::<u8>();
- true
- }
-
- fn visit_u16(&mut self) -> bool {
- self.align_to::<u16>();
- if ! self.inner.visit_u16() { return false; }
- self.bump_past::<u16>();
- true
- }
-
- fn visit_u32(&mut self) -> bool {
- self.align_to::<u32>();
- if ! self.inner.visit_u32() { return false; }
- self.bump_past::<u32>();
- true
- }
-
- fn visit_u64(&mut self) -> bool {
- self.align_to::<u64>();
- if ! self.inner.visit_u64() { return false; }
- self.bump_past::<u64>();
- true
- }
-
- fn visit_f32(&mut self) -> bool {
- self.align_to::<f32>();
- if ! self.inner.visit_f32() { return false; }
- self.bump_past::<f32>();
- true
- }
-
- fn visit_f64(&mut self) -> bool {
- self.align_to::<f64>();
- if ! self.inner.visit_f64() { return false; }
- self.bump_past::<f64>();
- true
- }
-
- fn visit_f128(&mut self) -> bool {
- self.align_to::<f128>();
- if ! self.inner.visit_f128() { return false; }
- self.bump_past::<f128>();
- true
- }
-
- fn visit_char(&mut self) -> bool {
- self.align_to::<char>();
- if ! self.inner.visit_char() { return false; }
- self.bump_past::<char>();
- 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::<Box<u8>>();
- if ! self.inner.visit_uniq(mtbl, inner) { return false; }
- self.bump_past::<Box<u8>>();
- 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::<Box<TyVisitor>>();
- if ! self.inner.visit_trait(name) { return false; }
- self.bump_past::<Box<TyVisitor>>();
- 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
- }
-}
+++ /dev/null
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<VariantState>,
- writer: &'a mut io::Writer,
- last_err: Option<io::IoError>,
-}
-
-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<T>(&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<T:Repr>(&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::<bool>() }
- fn visit_int(&mut self) -> bool { self.write::<int>() }
- fn visit_i8(&mut self) -> bool { self.write::<i8>() }
- fn visit_i16(&mut self) -> bool { self.write::<i16>() }
- fn visit_i32(&mut self) -> bool { self.write::<i32>() }
- fn visit_i64(&mut self) -> bool { self.write::<i64>() }
-
- fn visit_uint(&mut self) -> bool { self.write::<uint>() }
- fn visit_u8(&mut self) -> bool { self.write::<u8>() }
- fn visit_u16(&mut self) -> bool { self.write::<u16>() }
- fn visit_u32(&mut self) -> bool { self.write::<u32>() }
- fn visit_u64(&mut self) -> bool { self.write::<u64>() }
-
- fn visit_f32(&mut self) -> bool { self.write::<f32>() }
- fn visit_f64(&mut self) -> bool { self.write::<f64>() }
- fn visit_f128(&mut self) -> bool { fail!("not implemented") }
-
- fn visit_char(&mut self) -> bool {
- self.get::<char>(|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<raw::Vec<()>>>(|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::<raw::Slice<()>>(|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<T>(writer: &mut io::Writer, object: &T) -> io::IoResult<()> {
- unsafe {
- let ptr = object as *T as *u8;
- let tydesc = get_tydesc::<T>();
- 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: &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: &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::<int>, "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)");
-}
/// 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};
}
}
-#[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<Box<Task>> = 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("<unknown>");
- 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
}
#[lang="eh_personality"]
- #[cfg(not(stage0))]
extern fn eh_personality(
version: c_int,
actions: uw::_Unwind_Action,
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(
}
#[lang="eh_personality"]
- #[cfg(not(stage0))]
extern "C" fn eh_personality(
state: uw::_Unwind_State,
ue_header: *uw::_Unwind_Exception,
}
}
- #[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,
}
// 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
+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
projects / rust.git / commitdiff