---

yaml
---
r: 139421
b: refs/heads/try2
c: 4675022
h: refs/heads/master
i:
  139419: 575f58b
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7a6cd2b21e240d3b075b30d598e661b038fe6fbe
+refs/heads/try2: 467502216efabae9e209b30702fc9444b184de7a
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -1,4 +1,4 @@
-Version 0.6 (April 2013)
+Version 0.6 (March 2013)
 ---------------------------
 
    * ~2100 changes, numerous bugfixes

branches/try2/configure

@@ -533,7 +533,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-	(3.2svn|3.2|3.1svn|3.1|3.0svn|3.0)
+	(3.1svn|3.1|3.0svn|3.0)
 	    msg "found ok version of LLVM: $LLVM_VERSION"
 	    ;;
 	(*)

branches/try2/doc/tutorial.md

@@ -875,8 +875,7 @@ the compiler that unsafety does not leak outside of the unsafe block, and is
 used to create safe concepts on top of low-level code.
 
 ~~~~
-use core::libc::funcs::c95::stdlib::{calloc, free};
-use core::libc::types::os::arch::c95::size_t;
+use core::libc::{calloc, free, size_t};
 
 fn main() {
     unsafe {
@@ -909,9 +908,7 @@ The unsafe code from above can be contained behind a safe API that prevents
 memory leaks or use-after-free:
 
 ~~~~
-use core::libc::funcs::c95::stdlib::{calloc, free};
-use core::libc::types::common::c95::c_void;
-use core::libc::types::os::arch::c95::size_t;
+use core::libc::{calloc, free, c_void, size_t};
 
 struct Blob { priv ptr: *c_void }
 

branches/try2/src/libcore/str.rs

@@ -726,8 +726,7 @@ pub fn each_split_within<'a>(ss: &'a str,
 
             (B, Cr, UnderLim) => { B }
             (B, Cr, OverLim)  if (i - last_start + 1) > lim
-                              => fail!(fmt!("word starting with %? longer than limit!",
-                                            self::slice(ss, last_start, i + 1))),
+                              => { fail!(~"word longer than limit!") }
             (B, Cr, OverLim)  => { slice(); slice_start = last_start; B }
             (B, Ws, UnderLim) => { last_end = i; C }
             (B, Ws, OverLim)  => { last_end = i; slice(); A }

branches/try2/src/libcore/unstable/extfmt.rs

@@ -470,6 +470,9 @@ pub mod ct {
 // decisions made a runtime. If it proves worthwhile then some of these
 // conditions can be evaluated at compile-time. For now though it's cleaner to
 // implement it this way, I think.
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 #[doc(hidden)]
 pub mod rt {
     use float;
@@ -673,6 +676,192 @@ pub mod rt {
     }
 }
 
+// XXX: remove after a snapshot of the above changes have gone in
+#[cfg(stage0)]
+#[doc(hidden)]
+pub mod rt {
+    use float;
+    use str;
+    use sys;
+    use uint;
+    use vec;
+
+    pub static flag_none : u32 = 0u32;
+    pub static flag_left_justify   : u32 = 0b00000000000001u32;
+    pub static flag_left_zero_pad  : u32 = 0b00000000000010u32;
+    pub static flag_space_for_sign : u32 = 0b00000000000100u32;
+    pub static flag_sign_always    : u32 = 0b00000000001000u32;
+    pub static flag_alternate      : u32 = 0b00000000010000u32;
+
+    pub enum Count { CountIs(uint), CountImplied, }
+
+    pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
+
+    pub struct Conv {
+        flags: u32,
+        width: Count,
+        precision: Count,
+        ty: Ty,
+    }
+
+    pub fn conv_int(cv: Conv, i: int) -> ~str {
+        let radix = 10;
+        let prec = get_int_precision(cv);
+        let mut s : ~str = int_to_str_prec(i, radix, prec);
+        if 0 <= i {
+            if have_flag(cv.flags, flag_sign_always) {
+                unsafe { str::unshift_char(&mut s, '+') };
+            } else if have_flag(cv.flags, flag_space_for_sign) {
+                unsafe { str::unshift_char(&mut s, ' ') };
+            }
+        }
+        return unsafe { pad(cv, s, PadSigned) };
+    }
+    pub fn conv_uint(cv: Conv, u: uint) -> ~str {
+        let prec = get_int_precision(cv);
+        let mut rs =
+            match cv.ty {
+              TyDefault => uint_to_str_prec(u, 10, prec),
+              TyHexLower => uint_to_str_prec(u, 16, prec),
+              TyHexUpper => str::to_upper(uint_to_str_prec(u, 16, prec)),
+              TyBits => uint_to_str_prec(u, 2, prec),
+              TyOctal => uint_to_str_prec(u, 8, prec)
+            };
+        return unsafe { pad(cv, rs, PadUnsigned) };
+    }
+    pub fn conv_bool(cv: Conv, b: bool) -> ~str {
+        let s = if b { ~"true" } else { ~"false" };
+        // run the boolean conversion through the string conversion logic,
+        // giving it the same rules for precision, etc.
+        return conv_str(cv, s);
+    }
+    pub fn conv_char(cv: Conv, c: char) -> ~str {
+        let mut s = str::from_char(c);
+        return unsafe { pad(cv, s, PadNozero) };
+    }
+    pub fn conv_str(cv: Conv, s: &str) -> ~str {
+        // For strings, precision is the maximum characters
+        // displayed
+        let mut unpadded = match cv.precision {
+          CountImplied => s.to_owned(),
+          CountIs(max) => if (max as uint) < str::char_len(s) {
+            str::substr(s, 0, max as uint).to_owned()
+          } else {
+            s.to_owned()
+          }
+        };
+        return unsafe { pad(cv, unpadded, PadNozero) };
+    }
+    pub fn conv_float(cv: Conv, f: float) -> ~str {
+        let (to_str, digits) = match cv.precision {
+              CountIs(c) => (float::to_str_exact, c as uint),
+              CountImplied => (float::to_str_digits, 6u)
+        };
+        let mut s = unsafe { to_str(f, digits) };
+        if 0.0 <= f {
+            if have_flag(cv.flags, flag_sign_always) {
+                s = ~"+" + s;
+            } else if have_flag(cv.flags, flag_space_for_sign) {
+                s = ~" " + s;
+            }
+        }
+        return unsafe { pad(cv, s, PadFloat) };
+    }
+    pub fn conv_poly<T>(cv: Conv, v: &T) -> ~str {
+        let s = sys::log_str(v);
+        return conv_str(cv, s);
+    }
+
+    // Convert an int to string with minimum number of digits. If precision is
+    // 0 and num is 0 then the result is the empty string.
+    pub fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str {
+        return if num < 0 {
+                ~"-" + uint_to_str_prec(-num as uint, radix, prec)
+            } else { uint_to_str_prec(num as uint, radix, prec) };
+    }
+
+    // Convert a uint to string with a minimum number of digits.  If precision
+    // is 0 and num is 0 then the result is the empty string. Could move this
+    // to uint: but it doesn't seem all that useful.
+    pub fn uint_to_str_prec(num: uint, radix: uint,
+                                 prec: uint) -> ~str {
+        return if prec == 0u && num == 0u {
+                ~""
+            } else {
+                let s = uint::to_str_radix(num, radix);
+                let len = str::char_len(s);
+                if len < prec {
+                    let diff = prec - len;
+                    let pad = str::from_chars(vec::from_elem(diff, '0'));
+                    pad + s
+                } else { s }
+            };
+    }
+    pub fn get_int_precision(cv: Conv) -> uint {
+        return match cv.precision {
+              CountIs(c) => c as uint,
+              CountImplied => 1u
+            };
+    }
+
+    #[deriving(Eq)]
+    pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
+
+    pub fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
+        let mut s = s; // sadtimes
+        let uwidth : uint = match cv.width {
+          CountImplied => return (s),
+          CountIs(width) => { width as uint }
+        };
+        let strlen = str::char_len(s);
+        if uwidth <= strlen { return (s); }
+        let mut padchar = ' ';
+        let diff = uwidth - strlen;
+        if have_flag(cv.flags, flag_left_justify) {
+            let padstr = str::from_chars(vec::from_elem(diff, padchar));
+            return s + padstr;
+        }
+        let (might_zero_pad, signed) = match mode {
+          PadNozero   => (false, true),
+          PadSigned   => (true, true),
+          PadFloat    => (true, true),
+          PadUnsigned => (true, false)
+        };
+        fn have_precision(cv: Conv) -> bool {
+            return match cv.precision { CountImplied => false, _ => true };
+        }
+        let zero_padding = {
+            if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
+                (!have_precision(cv) || mode == PadFloat) {
+                padchar = '0';
+                true
+            } else {
+                false
+            }
+        };
+        let padstr = str::from_chars(vec::from_elem(diff, padchar));
+        // This is completely heinous. If we have a signed value then
+        // potentially rip apart the intermediate result and insert some
+        // zeros. It may make sense to convert zero padding to a precision
+        // instead.
+
+        if signed && zero_padding && s.len() > 0 {
+            let head = str::shift_char(&mut s);
+            if head == '+' || head == '-' || head == ' ' {
+                let headstr = str::from_chars(vec::from_elem(1u, head));
+                return headstr + padstr + s;
+            }
+            else {
+                str::unshift_char(&mut s, head);
+            }
+        }
+        return padstr + s;
+    }
+    pub fn have_flag(flags: u32, f: u32) -> bool {
+        flags & f != 0
+    }
+}
+
 // Bulk of the tests are in src/test/run-pass/syntax-extension-fmt.rs
 #[cfg(test)]
 mod test {

branches/try2/src/libcore/unstable/lang.rs

@@ -64,7 +64,6 @@ pub unsafe fn fail_borrowed() {
 
 // FIXME #4942: Make these signatures agree with exchange_alloc's signatures
 #[lang="exchange_malloc"]
-#[inline(always)]
 pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     transmute(exchange_alloc::malloc(transmute(td), transmute(size)))
 }
@@ -73,13 +72,11 @@ pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[lang="exchange_free"]
-#[inline(always)]
 pub unsafe fn exchange_free(ptr: *c_char) {
     exchange_alloc::free(transmute(ptr))
 }
 
 #[lang="malloc"]
-#[inline(always)]
 pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_malloc(td, size);
 }
@@ -88,7 +85,6 @@ pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[lang="free"]
-#[inline(always)]
 pub unsafe fn local_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);
 }
@@ -121,7 +117,6 @@ pub unsafe fn check_not_borrowed(a: *u8) {
 }
 
 #[lang="strdup_uniq"]
-#[inline(always)]
 pub unsafe fn strdup_uniq(ptr: *c_uchar, len: uint) -> ~str {
     str::raw::from_buf_len(ptr, len)
 }

branches/try2/src/librustc/driver/driver.rs

@@ -762,7 +762,8 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
   optflag(~"", ~"test", ~"Build a test harness"),
   optopt(~"", ~"target",
                         ~"Target triple cpu-manufacturer-kernel[-os]
-                          to compile for (see chapter 3.4 of http://www.sourceware.org/autobook/
+                          to compile for (see
+         http://sources.redhat.com/autobook/autobook/autobook_17.html
                           for detail)", ~"TRIPLE"),
   optopt(~"", ~"android-cross-path",
          ~"The path to the Android NDK", "PATH"),

branches/try2/src/librustc/metadata/encoder.rs

@@ -286,7 +286,8 @@ fn encode_enum_variant_info(ecx: @EncodeContext, ebml_w: writer::Encoder,
                     if args.len() > 0 && generics.ty_params.len() == 0 => {
                 encode_symbol(ecx, ebml_w, variant.node.id);
             }
-            ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) => {}
+            ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) |
+            ast::enum_variant_kind(_) => {}
         }
         encode_discriminant(ecx, ebml_w, variant.node.id);
         if vi[i].disr_val != disr_val {

branches/try2/src/librustc/middle/liveness.rs

@@ -1306,11 +1306,11 @@ pub impl Liveness {
             self.propagate_through_expr(e, succ)
           }
 
-          expr_inline_asm(ref ia) =>{
-            let succ = do ia.inputs.foldr(succ) |&(_, expr), succ| {
+          expr_inline_asm(_, ref ins, ref outs, _, _, _) =>{
+            let succ = do ins.foldr(succ) |&(_, expr), succ| {
                 self.propagate_through_expr(expr, succ)
             };
-            do ia.outputs.foldr(succ) |&(_, expr), succ| {
+            do outs.foldr(succ) |&(_, expr), succ| {
                 self.propagate_through_expr(expr, succ)
             }
           }
@@ -1580,19 +1580,14 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
         visit::visit_expr(expr, self, vt);
       }
 
-      expr_inline_asm(ref ia) => {
-        for ia.inputs.each |&(_, in)| {
+      expr_inline_asm(_, ref ins, ref outs, _, _, _) => {
+        for ins.each |&(_, in)| {
           (vt.visit_expr)(in, self, vt);
         }
 
         // Output operands must be lvalues
-        for ia.outputs.each |&(_, out)| {
-          match out.node {
-            expr_addr_of(_, inner) => {
-              self.check_lvalue(inner, vt);
-            }
-            _ => {}
-          }
+        for outs.each |&(_, out)| {
+          self.check_lvalue(out, vt);
           (vt.visit_expr)(out, self, vt);
         }
 

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

@@ -37,7 +37,7 @@ use syntax::ast::{expr_binary, expr_break, expr_cast, expr_field};
 use syntax::ast::{expr_fn_block, expr_index, expr_method_call, expr_path};
 use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param};
 use syntax::ast::{def_upvar, def_use, def_variant, div, eq};
-use syntax::ast::{expr, expr_again, expr_assign_op};
+use syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op};
 use syntax::ast::{expr_index, expr_loop};
 use syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl};
 use syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge};
@@ -1383,6 +1383,16 @@ pub impl Resolver {
                                   variant.span);
                 self.structs.insert(local_def(variant.node.id));
             }
+            enum_variant_kind(ref enum_definition) => {
+                child.define_type(privacy,
+                                  def_ty(local_def(variant.node.id)),
+                                  variant.span);
+                for (*enum_definition).variants.each |variant| {
+                    self.build_reduced_graph_for_variant(*variant, item_id,
+                                                         parent_privacy,
+                                                         parent, visitor);
+                }
+            }
         }
     }