---

yaml
---
r: 85726
b: refs/heads/dist-snap
c: 4c5f625
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: a9d28b2d9d9939b1134d48feb1d83864bae782d5
+refs/heads/dist-snap: 4c5f62539b51c6c8f45bd8e2e79b81fd1480906a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/rt.mk

@@ -75,6 +75,7 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_gc_metadata.cpp \
               rt/rust_util.cpp \
               rt/rust_log.cpp \
+              rt/rust_exchange_alloc.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
               rt/rust_abi.cpp \

branches/dist-snap/src/libextra/time.rs

@@ -121,9 +121,6 @@ pub struct Tm {
 }
 
 pub fn empty_tm() -> Tm {
-    // 64 is the max size of the timezone buffer allocated on windows
-    // in rust_localtime. In glibc the max timezone size is supposedly 3.
-    let zone = str::with_capacity(64);
     Tm {
         tm_sec: 0_i32,
         tm_min: 0_i32,
@@ -135,7 +132,7 @@ pub fn empty_tm() -> Tm {
         tm_yday: 0_i32,
         tm_isdst: 0_i32,
         tm_gmtoff: 0_i32,
-        tm_zone: zone,
+        tm_zone: ~"",
         tm_nsec: 0_i32,
     }
 }

branches/dist-snap/src/libstd/vec.rs

@@ -3154,7 +3154,6 @@ mod tests {
         }
     }
 
-    #[ignore] // FIXME #8698
     #[test]
     #[should_fail]
     fn test_map_fail() {
@@ -3164,12 +3163,11 @@ mod tests {
             if i == 2 {
                 fail!()
             }
-            i += 0;
+            i += 1;
             ~[(~0, @0)]
         };
     }
 
-    #[ignore] // FIXME #8698
     #[test]
     #[should_fail]
     fn test_flat_map_fail() {
@@ -3179,12 +3177,11 @@ mod tests {
             if i == 2 {
                 fail!()
             }
-            i += 0;
+            i += 1;
             ~[(~0, @0)]
         };
     }
 
-    #[ignore] // FIXME #8698
     #[test]
     #[should_fail]
     fn test_rposition_fail() {
@@ -3194,12 +3191,11 @@ mod tests {
             if i == 2 {
                 fail!()
             }
-            i += 0;
+            i += 1;
             false
         };
     }
 
-    #[ignore] // FIXME #8698
     #[test]
     #[should_fail]
     fn test_permute_fail() {
@@ -3209,7 +3205,7 @@ mod tests {
             if i == 2 {
                 fail!()
             }
-            i += 0;
+            i += 1;
             true
         };
     }

branches/dist-snap/src/rt/rust_builtin.cpp

@@ -292,7 +292,7 @@ void tm_to_rust_tm(tm* in_tm, rust_tm* out_tm, int32_t gmtoff,
 
     if (zone != NULL) {
         size_t size = strlen(zone);
-        assert(out_tm->tm_zone->alloc >= size);
+        reserve_vec_exact(&out_tm->tm_zone, size);
         memcpy(out_tm->tm_zone->data, zone, size);
         out_tm->tm_zone->fill = size;
     }

branches/dist-snap/src/rt/rust_exchange_alloc.cpp

@@ -0,0 +1,35 @@
+// Copyright 2013 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.
+
+#include "rust_exchange_alloc.h"
+#include "sync/sync.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+void *
+rust_exchange_alloc::malloc(size_t size) {
+  void *value = ::malloc(size);
+  assert(value);
+  return value;
+}
+
+void *
+rust_exchange_alloc::realloc(void *ptr, size_t size) {
+  void *new_ptr = ::realloc(ptr, size);
+  assert(new_ptr);
+  return new_ptr;
+}
+
+void
+rust_exchange_alloc::free(void *ptr) {
+  ::free(ptr);
+}

branches/dist-snap/src/rt/rust_exchange_alloc.h

@@ -0,0 +1,24 @@
+// Copyright 2013 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.
+
+#ifndef RUST_EXCHANGE_ALLOC_H
+#define RUST_EXCHANGE_ALLOC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+class rust_exchange_alloc {
+ public:
+    void *malloc(size_t size);
+    void *realloc(void *mem, size_t size);
+    void free(void *mem);
+};
+
+#endif

branches/dist-snap/src/rt/rust_util.h

@@ -12,6 +12,7 @@
 #define RUST_UTIL_H
 
 #include <limits.h>
+#include "rust_exchange_alloc.h"
 #include "rust_type.h"
 
 extern struct type_desc str_body_tydesc;
@@ -56,6 +57,16 @@ vec_data(rust_vec *v) {
     return reinterpret_cast<T*>(v->data);
 }
 
+inline void reserve_vec_exact(rust_vec** vpp,
+                              size_t size) {
+    if (size > (*vpp)->alloc) {
+        rust_exchange_alloc exchange_alloc;
+        *vpp = (rust_vec*)exchange_alloc
+            .realloc(*vpp, size + sizeof(rust_vec));
+        (*vpp)->alloc = size;
+    }
+}
+
 typedef rust_vec rust_str;
 
 inline size_t get_box_size(size_t body_size, size_t body_align) {

branches/dist-snap/src/rt/util/indexed_list.h

@@ -0,0 +1,115 @@
+// Copyright 2012 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.
+
+#ifndef INDEXED_LIST_H
+#define INDEXED_LIST_H
+
+#include <assert.h>
+#include "array_list.h"
+
+class indexed_list_object {
+public:
+    virtual ~indexed_list_object() {}
+    int32_t list_index;
+};
+
+template<typename T>
+class indexed_list_element : public indexed_list_object {
+public:
+    T value;
+    indexed_list_element(T value) : value(value) {
+    }
+};
+
+/**
+ * An array list of objects that are aware of their position in the list.
+ * Normally, objects in this list should derive from the base class
+ * "indexed_list_object" however because of nasty Rust compiler dependencies
+ * on the layout of runtime objects we cannot always derive from this
+ * base class, so instead we just enforce the informal protocol that any
+ * object inserted in this list must define a "int32_t list_index" member.
+ */
+template<typename T> class indexed_list {
+    array_list<T*> list;
+public:
+    int32_t append(T *value);
+    bool pop(T **value);
+    /**
+     * Same as pop(), except that it returns NULL if the list is empty.
+     */
+    T* pop_value();
+    size_t length() const {
+        return list.size();
+    }
+    bool is_empty() const {
+        return list.is_empty();
+    }
+    int32_t remove(T* value);
+    T * operator[](int32_t index);
+    const T * operator[](int32_t index) const;
+    ~indexed_list() {}
+};
+
+template<typename T> int32_t
+indexed_list<T>::append(T *value) {
+    value->list_index = list.push(value);
+    return value->list_index;
+}
+
+/**
+ * Swap delete the last object in the list with the specified object.
+ */
+template<typename T> int32_t
+indexed_list<T>::remove(T *value) {
+    assert (value->list_index >= 0);
+    assert (value->list_index < (int32_t)list.size());
+    int32_t removeIndex = value->list_index;
+    T *last = 0;
+    list.pop(&last);
+    if (last->list_index == removeIndex) {
+        last->list_index = -1;
+        return removeIndex;
+    } else {
+        value->list_index = -1;
+        list[removeIndex] = last;
+        last->list_index = removeIndex;
+        return removeIndex;
+    }
+}
+
+template<typename T> bool
+indexed_list<T>::pop(T **value) {
+    return list.pop(value);
+}
+
+template<typename T> T*
+indexed_list<T>::pop_value() {
+    T *value = NULL;
+    if (list.pop(&value)) {
+        return value;
+    }
+    return NULL;
+}
+
+template <typename T> T *
+indexed_list<T>::operator[](int32_t index) {
+    T *value = list[index];
+    assert(value->list_index == index);
+    return value;
+}
+
+template <typename T> const T *
+indexed_list<T>::operator[](int32_t index) const {
+    T *value = list[index];
+    assert(value->list_index == index);
+    return value;
+}
+
+#endif /* INDEXED_LIST_H */