1
Fork 0

Merge remote-tracking branch 'remotes/origin/incoming' into serial

This commit is contained in:
Erick Tryzelaar 2013-03-29 17:41:32 -07:00
commit 529ae38605
8 changed files with 88 additions and 120 deletions

4
configure vendored
View file

@ -881,6 +881,10 @@ do
;; ;;
esac esac
need_ok "LLVM configure failed" need_ok "LLVM configure failed"
# Hack the tools Makefile to turn off the clang build
sed -i 's/clang//g' tools/Makefile
cd $CFG_BUILD_DIR cd $CFG_BUILD_DIR
fi fi

View file

@ -1002,11 +1002,46 @@ refer to that through a pointer.
## Owned boxes ## Owned boxes
An owned box (`~`) is a uniquely owned allocation on the heap. An owned box An owned box (`~`) is a uniquely owned allocation on the heap. It inherits the
inherits the mutability and lifetime of the owner as it would if there was no mutability and lifetime of the owner as it would if there was no box.
box. The purpose of an owned box is to add a layer of indirection in order to
create recursive data structures or cheaply pass around an object larger than a ~~~~
pointer. let x = 5; // immutable
let mut y = 5; // mutable
y += 2;
let x = ~5; // immutable
let mut y = ~5; // mutable
*y += 2; // the * operator is needed to access the contained value
~~~~
The purpose of an owned box is to add a layer of indirection in order to create
recursive data structures or cheaply pass around an object larger than a
pointer. Since an owned box has a unique owner, it can be used to represent any
tree data structure.
The following struct won't compile, because the lack of indirection would mean
it has an infinite size:
~~~~ {.xfail-test}
struct Foo {
child: Option<Foo>
}
~~~~
> ***Note:*** The `Option` type is an enum that represents an *optional* value.
> It's comparable to a nullable pointer in many other languages, but stores the
> contained value unboxed.
Adding indirection with an owned pointer allocates the child outside of the
struct on the heap, which makes it a finite size and won't result in a
compile-time error:
~~~~
struct Foo {
child: Option<~Foo>
}
~~~~
## Managed boxes ## Managed boxes
@ -1018,6 +1053,20 @@ mutability. They do own the contained object, and mutability is defined by the
type of the shared box (`@` or `@mut`). An object containing a managed box is type of the shared box (`@` or `@mut`). An object containing a managed box is
not `Owned`, and can't be sent between tasks. not `Owned`, and can't be sent between tasks.
~~~~
let a = @5; // immutable
let mut b = @5; // mutable variable, immutable box
b = @10;
let c = @mut 5; // immutable variable, mutable box
*c = 10;
let mut d = @mut 5; // mutable variable, mutable box
*d += 5;
d = @mut 15;
~~~~
# Move semantics # Move semantics
Rust uses a shallow copy for parameter passing, assignment and returning values Rust uses a shallow copy for parameter passing, assignment and returning values
@ -1035,10 +1084,10 @@ let z = x; // no new memory allocated, x can no longer be used
# Borrowed pointers # Borrowed pointers
Rust's borrowed pointers are a general purpose reference type. In contrast with Rust's borrowed pointers are a general purpose reference type. In contrast with
owned pointers, where the holder of an owned pointer is the owner of the owned boxes, where the holder of an owned box is the owner of the pointed-to
pointed-to memory, borrowed pointers never imply ownership. A pointer can be memory, borrowed pointers never imply ownership. A pointer can be borrowed to
borrowed to any object, and the compiler verifies that it cannot outlive the any object, and the compiler verifies that it cannot outlive the lifetime of
lifetime of the object. the object.
As an example, consider a simple struct type, `Point`: As an example, consider a simple struct type, `Point`:
@ -1124,10 +1173,7 @@ For a more in-depth explanation of borrowed pointers, read the
## Freezing ## Freezing
Borrowing an immutable pointer to an object freezes it and prevents mutation. Borrowing an immutable pointer to an object freezes it and prevents mutation.
`Owned` objects have freezing enforced statically at compile-time. Mutable `Owned` objects have freezing enforced statically at compile-time.
managed boxes handle freezing dynamically when any of their contents are
borrowed, and the task will fail if an attempt to modify them is made while
they are frozen.
~~~~ ~~~~
let mut x = 5; let mut x = 5;
@ -1137,6 +1183,20 @@ let mut x = 5;
// x is now unfrozen again // x is now unfrozen again
~~~~ ~~~~
Mutable managed boxes handle freezing dynamically when any of their contents
are borrowed, and the task will fail if an attempt to modify them is made while
they are frozen:
~~~~
let x = @mut 5;
let y = x;
{
let y = &*y; // the managed box is now frozen
// modifying it through x or y will cause a task failure
}
// the box is now unfrozen again
~~~~
# Dereferencing pointers # Dereferencing pointers
Rust uses the unary star operator (`*`) to access the contents of a Rust uses the unary star operator (`*`) to access the contents of a

View file

@ -681,45 +681,6 @@ impl vtable_decoder_helpers for reader::Decoder {
@self.read_to_vec(|| self.read_vtable_origin(xcx) ) @self.read_to_vec(|| self.read_vtable_origin(xcx) )
} }
#[cfg(stage0)]
fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
-> typeck::vtable_origin {
do self.read_enum(~"vtable_origin") {
do self.read_enum_variant |i| {
match i {
0 => {
typeck::vtable_static(
do self.read_enum_variant_arg(0u) {
self.read_def_id(xcx)
},
do self.read_enum_variant_arg(1u) {
self.read_tys(xcx)
},
do self.read_enum_variant_arg(2u) {
self.read_vtable_res(xcx)
}
)
}
1 => {
typeck::vtable_param(
do self.read_enum_variant_arg(0u) {
self.read_uint()
},
do self.read_enum_variant_arg(1u) {
self.read_uint()
}
)
}
// hard to avoid - user input
_ => fail!(~"bad enum variant")
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext) fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
-> typeck::vtable_origin { -> typeck::vtable_origin {
do self.read_enum("vtable_origin") { do self.read_enum("vtable_origin") {

View file

@ -321,19 +321,6 @@ pub mod reader {
self.push_doc(self.next_doc(EsEnum), f) self.push_doc(self.next_doc(EsEnum), f)
} }
#[cfg(stage0)]
fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_enum_variant()");
let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx)
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_enum_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T { fn read_enum_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T {
debug!("read_enum_variant()"); debug!("read_enum_variant()");
let idx = self._next_uint(EsEnumVid); let idx = self._next_uint(EsEnumVid);
@ -373,23 +360,6 @@ pub mod reader {
f() f()
} }
#[cfg(stage0)]
fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
debug!("read_option()");
do self.read_enum("Option") || {
do self.read_enum_variant |idx| {
match idx {
0 => f(false),
1 => f(true),
_ => fail!(),
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_option<T>(&self, f: &fn(bool) -> T) -> T { fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
debug!("read_option()"); debug!("read_option()");
do self.read_enum("Option") || { do self.read_enum("Option") || {

View file

@ -803,19 +803,6 @@ impl serialize::Decoder for Decoder {
f() f()
} }
#[cfg(stage0)]
fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_enum_variant()");
let idx = match self.stack.pop() {
Null => { self.stack.push(Null); 0 },
value => { self.stack.push(value); 1 },
};
f(idx)
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T { fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T {
debug!("read_enum_variant(names=%?)", names); debug!("read_enum_variant(names=%?)", names);
let name = match self.stack.pop() { let name = match self.stack.pop() {

View file

@ -83,11 +83,6 @@ pub trait Decoder {
// Compound types: // Compound types:
fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T; fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T;
#[cfg(stage0)]
fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T;
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T; fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T; fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T;
@ -558,23 +553,6 @@ impl<
K: Decodable<D> + Hash + IterBytes + Eq, K: Decodable<D> + Hash + IterBytes + Eq,
V: Decodable<D> V: Decodable<D>
> Decodable<D> for LinearMap<K, V> { > Decodable<D> for LinearMap<K, V> {
#[cfg(stage0)]
fn decode(d: &D) -> LinearMap<K, V> {
do d.read_map |len| {
let mut map = LinearMap::new();
map.reserve_at_least(len);
for uint::range(0, len) |i| {
let key = d.read_map_elt_key(i, || Decodable::decode(d));
let val = d.read_map_elt_val(i, || Decodable::decode(d));
map.insert(key, val);
}
map
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn decode(d: &D) -> LinearMap<K, V> { fn decode(d: &D) -> LinearMap<K, V> {
do d.read_map |len| { do d.read_map |len| {
let mut map = LinearMap::with_capacity(len); let mut map = LinearMap::with_capacity(len);

View file

@ -1281,13 +1281,13 @@ mod test {
f(); f();
} }
fn read_map<T>(&self, f: &fn(uint) -> T) -> T { fn emit_map<T>(&self, f: &fn(uint) -> T) -> T {
self.add_unknown_to_log(); f(0); self.add_unknown_to_log(); f(0);
} }
fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T { fn emit_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T {
self.add_unknown_to_log(); f(); self.add_unknown_to_log(); f();
} }
fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T { fn emit_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T {
self.add_unknown_to_log(); f(); self.add_unknown_to_log(); f();
} }
} }

View file

@ -1,3 +1,11 @@
S 2013-03-28 f7a2371
macos-i386 2e05a33716fc4982db53946c3b0dccf0194826fe
macos-x86_64 fbd3feec8dd17a6b6c8df114e6e9b4cd17cc6172
linux-i386 b89197edd3ba5be7c2ee6577f048d7663640e1d1
linux-x86_64 61a4377c6d0ca5814c2b2b752d73b61b741a23c9
winnt-i386 858a74afb210b30697227a87b67e44786b383a0c
freebsd-x86_64 01f1e4b94504045e763eecb71c7e0852f6e85036
S 2013-03-27 8c15409 S 2013-03-27 8c15409
macos-x86_64 05eb3801b60056d95715c891d00c5d372e34d00c macos-x86_64 05eb3801b60056d95715c891d00c5d372e34d00c
macos-i386 4119e3fa614fa86adf60ed0183d00db3ce6d0dbc macos-i386 4119e3fa614fa86adf60ed0183d00db3ce6d0dbc