---

yaml
---
r: 93791
b: refs/heads/try
c: 248cb90
h: refs/heads/master
i:
  93789: 18af3ca
  93787: 81f060b
  93783: 1646d1d
  93775: 5230750
  93759: 7b39f12
v: v3

Author: hatahet

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 97aaf42462ff35ad2bf097c8c1351e876d8d72b8
+refs/heads/try: 248cb90dfa00a7efdd51eb457afd9b59246b2d24
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/configure

@@ -520,20 +520,14 @@ then
     fi
 fi
 
-BIN_SUF=
-if [ $CFG_OSTYPE = "pc-mingw32" ]
-then
-    BIN_SUF=.exe
-fi
-
 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 then
-    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
+    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
     then
         err "no local rust to use"
     else
-        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --version`
-        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
+        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
+        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
     fi
 fi
 

branches/try/doc/rust.md

@@ -1131,8 +1131,9 @@ block.
 let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~~
 
-Extern functions may be called directly from Rust code as Rust uses large,
-contiguous stack segments like C.
+Extern functions may be called from Rust code, but
+caution must be taken with respect to the size of the stack
+segment, just as when calling an extern function normally.
 
 ### Type definitions
 
@@ -3161,7 +3162,7 @@ Borrowed pointers (`&`)
     Borrowed pointers arise by (automatic) conversion from owning pointers, managed pointers,
     or by applying the borrowing operator `&` to some other value,
     including [lvalues, rvalues or temporaries](#lvalues-rvalues-and-temporaries).
-    Borrowed pointers are written `&content`, or in some cases `&'f content` for some lifetime-variable `f`,
+    Borrowed pointers are written `&content`, or in some cases `&f/content` for some lifetime-variable `f`,
     for example `&int` means a borrowed pointer to an integer.
     Copying a borrowed pointer is a "shallow" operation:
     it involves only copying the pointer itself.
@@ -3596,9 +3597,9 @@ and releases them back to its environment when they are no longer needed.
 The default implementation of the service-provider interface
 consists of the C runtime functions `malloc` and `free`.
 
-The runtime memory-management system, in turn, supplies Rust tasks with
-facilities for allocating releasing stacks, as well as allocating and freeing
-heap data.
+The runtime memory-management system, in turn, supplies Rust tasks
+with facilities for allocating, extending and releasing stacks,
+as well as allocating and freeing heap data.
 
 ### Built in types
 
@@ -3761,6 +3762,7 @@ have come and gone during the course of Rust's development:
 
 Additional specific influences can be seen from the following languages:
 
+* The stack-growth implementation of Go.
 * The structural algebraic types and compilation manager of SML.
 * The attribute and assembly systems of C#.
 * The references and deterministic destructor system of C++.

branches/try/src/etc/local_stage0.sh

@@ -3,8 +3,8 @@
 TARG_DIR=$1
 PREFIX=$2
 
-LIB_DIR=lib
-LIB_PREFIX=lib
+BINDIR=bin
+LIBDIR=lib
 
 OS=`uname -s`
 case $OS in
@@ -21,8 +21,7 @@ case $OS in
     (*)
 	BIN_SUF=.exe
 	LIB_SUF=.dll
-	LIB_DIR=bin
-	LIB_PREFIX=
+	LIBDIR=bin
 	break
 	;;
 esac
@@ -32,7 +31,7 @@ if [ -z $PREFIX ]; then
     exit 1
 fi
 
-if [ ! -e ${PREFIX}/bin/rustc${BIN_SUF} ]; then
+if [ ! -e ${PREFIX}/bin/rustc ]; then
     echo "No local rust installed at ${PREFIX}"
     exit 1
 fi
@@ -42,9 +41,9 @@ if [ -z $TARG_DIR ]; then
     exit 1
 fi
 
-cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/
-cp ${PREFIX}/${LIB_DIR}/rustc/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/bin/rustc ${TARG_DIR}/stage0/bin/
+cp ${PREFIX}/lib/rustc/${TARG_DIR}/${LIBDIR}/* ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libextra*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/librust*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libstd*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libsyntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/

branches/try/src/librustc/middle/resolve.rs

@@ -29,7 +29,7 @@ use syntax::parse::token;
 use syntax::parse::token::{ident_interner, interner_get};
 use syntax::parse::token::special_idents;
 use syntax::print::pprust::path_to_str;
-use syntax::codemap::{Span, dummy_sp, Pos};
+use syntax::codemap::{Span, dummy_sp, BytePos};
 use syntax::opt_vec::OptVec;
 use syntax::visit;
 use syntax::visit::Visitor;
@@ -2624,7 +2624,7 @@ impl Resolver {
                     if "???" == module_name {
                         let span = Span {
                             lo: span.lo,
-                            hi: span.lo + Pos::from_uint(segment_name.len()),
+                            hi: span.lo + BytePos(segment_name.len()),
                             expn_info: span.expn_info,
                         };
                         self.resolve_error(span,

branches/try/src/librustc/middle/typeck/astconv.rs

@@ -560,6 +560,10 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
             ast_ty.span,
             "found `ty_infer` in unexpected place");
       }
+      ast::ty_mac(_) => {
+        tcx.sess.span_bug(ast_ty.span,
+                          "found `ty_mac` in unexpected place");
+      }
     };
 
     tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ));

branches/try/src/libstd/ptr.rs

@@ -155,7 +155,7 @@ pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
  * Reads the value from `*src` and returns it. Does not copy `*src`.
  */
 #[inline(always)]
-pub unsafe fn read_ptr<T>(src: *mut T) -> T {
+pub unsafe fn read_ptr<T>(src: *T) -> T {
     let mut tmp: T = intrinsics::uninit();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
@@ -168,7 +168,7 @@ pub unsafe fn read_ptr<T>(src: *mut T) -> T {
 #[inline(always)]
 pub unsafe fn read_and_zero_ptr<T>(dest: *mut T) -> T {
     // Copy the data out from `dest`:
-    let tmp = read_ptr(dest);
+    let tmp = read_ptr(&*dest);
 
     // Now zero out `dest`:
     zero_memory(dest, 1);

branches/try/src/libstd/vec.rs

@@ -1527,7 +1527,7 @@ impl<T> OwnedVector<T> for ~[T] {
                 let valptr = ptr::to_mut_unsafe_ptr(&mut self[ln - 1u]);
                 unsafe {
                     raw::set_len(self, ln - 1u);
-                    Some(ptr::read_ptr(valptr))
+                    Some(ptr::read_ptr(&*valptr))
                 }
             }
         }

branches/try/src/libsyntax/ast.rs

@@ -861,6 +861,7 @@ pub enum ty_ {
     ty_bare_fn(@TyBareFn),
     ty_tup(~[Ty]),
     ty_path(Path, Option<OptVec<TyParamBound>>, NodeId), // for #7264; see above
+    ty_mac(mac),
     ty_typeof(@Expr),
     // ty_infer means the type should be inferred instead of it having been
     // specified. This should only appear at the "top level" of a type and not

branches/try/src/libsyntax/codemap.rs

@@ -29,11 +29,9 @@ pub trait Pos {
     fn to_uint(&self) -> uint;
 }
 
-/// A byte offset. Keep this small (currently 32-bits), as AST contains
-/// a lot of them.
+/// A byte offset
 #[deriving(Clone, Eq, IterBytes, Ord)]
-pub struct BytePos(u32);
-
+pub struct BytePos(uint);
 /// A character offset. Because of multibyte utf8 characters, a byte offset
 /// is not equivalent to a character offset. The CodeMap will convert BytePos
 /// values to CharPos values as necessary.
@@ -44,8 +42,8 @@ pub struct CharPos(uint);
 // have been unsuccessful
 
 impl Pos for BytePos {
-    fn from_uint(n: uint) -> BytePos { BytePos(n as u32) }
-    fn to_uint(&self) -> uint { **self as uint }
+    fn from_uint(n: uint) -> BytePos { BytePos(n) }
+    fn to_uint(&self) -> uint { **self }
 }
 
 impl Add<BytePos, BytePos> for BytePos {
@@ -280,7 +278,7 @@ impl CodeMap {
 
         let filemap = @FileMap {
             name: filename, substr: substr, src: src,
-            start_pos: Pos::from_uint(start_pos),
+            start_pos: BytePos(start_pos),
             lines: @mut ~[],
             multibyte_chars: @mut ~[],
         };

branches/try/src/libsyntax/fold.rs

@@ -277,6 +277,7 @@ pub trait ast_fold {
             ty_fixed_length_vec(ref mt, e) => {
                 ty_fixed_length_vec(fold_mt(mt, self), self.fold_expr(e))
             }
+            ty_mac(ref mac) => ty_mac(self.fold_mac(mac)),
             ty_typeof(expr) => ty_typeof(self.fold_expr(expr)),
         };
         Ty {

branches/try/src/libsyntax/parse/lexer.rs

@@ -247,7 +247,7 @@ pub fn bump(rdr: &mut StringReader) {
         let last_char = rdr.curr;
         let next = rdr.src.char_range_at(current_byte_offset);
         let byte_offset_diff = next.next - current_byte_offset;
-        rdr.pos = rdr.pos + Pos::from_uint(byte_offset_diff);
+        rdr.pos = rdr.pos + BytePos(byte_offset_diff);
         rdr.curr = next.ch;
         rdr.col = rdr.col + CharPos(1u);
         if last_char == '\n' {
@@ -257,7 +257,7 @@ pub fn bump(rdr: &mut StringReader) {
 
         if byte_offset_diff > 1 {
             rdr.filemap.record_multibyte_char(
-                Pos::from_uint(current_byte_offset), byte_offset_diff);
+                BytePos(current_byte_offset), byte_offset_diff);
         }
     } else {
         rdr.curr = unsafe { transmute(-1u32) }; // FIXME: #8971: unsound
@@ -333,7 +333,7 @@ fn consume_any_line_comment(rdr: @mut StringReader)
             bump(rdr);
             // line comments starting with "///" or "//!" are doc-comments
             if rdr.curr == '/' || rdr.curr == '!' {
-                let start_bpos = rdr.pos - BytePos(3);
+                let start_bpos = rdr.pos - BytePos(3u);
                 while rdr.curr != '\n' && !is_eof(rdr) {
                     bump(rdr);
                 }
@@ -387,7 +387,7 @@ fn consume_block_comment(rdr: @mut StringReader)
                       -> Option<TokenAndSpan> {
     // block comments starting with "/**" or "/*!" are doc-comments
     let is_doc_comment = rdr.curr == '*' || rdr.curr == '!';
-    let start_bpos = rdr.pos - BytePos(if is_doc_comment {3} else {2});
+    let start_bpos = rdr.pos - BytePos(if is_doc_comment {3u} else {2u});
 
     let mut level: int = 1;
     while level > 0 {
@@ -815,7 +815,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
                                // Byte offsetting here is okay because the
                                // character before position `start` is an
                                // ascii single quote.
-                               start - BytePos(1),
+                               start - BytePos(1u),
                                rdr.last_pos,
                                ~"unterminated character constant");
         }

branches/try/src/libsyntax/parse/mod.rs

@@ -349,7 +349,7 @@ mod test {
     }
 
     // produce a codemap::span
-    fn sp(a: u32, b: u32) -> Span {
+    fn sp (a: uint, b: uint) -> Span {
         Span{lo:BytePos(a),hi:BytePos(b),expn_info:None}
     }
 

branches/try/src/libsyntax/parse/parser.rs

@@ -606,7 +606,7 @@ impl Parser {
             token::GT => self.bump(),
             token::BINOP(token::SHR) => self.replace_token(
                 token::GT,
-                self.span.lo + BytePos(1),
+                self.span.lo + BytePos(1u),
                 self.span.hi
             ),
             _ => self.fatal(format!("expected `{}`, found `{}`",

branches/try/src/libsyntax/print/pprust.rs

@@ -459,6 +459,9 @@ pub fn print_type(s: @ps, ty: &ast::Ty) {
           print_expr(s, e);
           word(s.s, ")");
       }
+      ast::ty_mac(_) => {
+          fail!("print_type doesn't know how to print a ty_mac");
+      }
       ast::ty_infer => {
           fail!("print_type shouldn't see a ty_infer");
       }
@@ -2116,7 +2119,7 @@ pub fn maybe_print_trailing_comment(s: @ps, span: codemap::Span,
         if (*cmnt).style != comments::trailing { return; }
         let span_line = cm.lookup_char_pos(span.hi);
         let comment_line = cm.lookup_char_pos((*cmnt).pos);
-        let mut next = (*cmnt).pos + BytePos(1);
+        let mut next = (*cmnt).pos + BytePos(1u);
         match next_pos { None => (), Some(p) => next = p }
         if span.hi < (*cmnt).pos && (*cmnt).pos < next &&
                span_line.line == comment_line.line {

branches/try/src/libsyntax/visit.rs

@@ -314,7 +314,7 @@ pub fn walk_ty<E:Clone, V:Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) {
         ty_typeof(expression) => {
             visitor.visit_expr(expression, env)
         }
-        ty_nil | ty_bot | ty_infer => ()
+        ty_nil | ty_bot | ty_mac(_) | ty_infer => ()
     }
 }