---

yaml
---
r: 92788
b: refs/heads/auto
c: 3c4eb2b
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 00d87e0d8198ffb268251b5af2eb2ce19249c7f8
+refs/heads/auto: 3c4eb2b1d1e1dbebe42a9a93bd23b7eab8dc0f0f
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libextra/ebml.rs

@@ -593,13 +593,22 @@ pub mod writer {
     use std::io::extensions::u64_to_be_bytes;
 
     // ebml writing
-    pub struct Encoder<'a> {
+    pub struct Encoder {
         // FIXME(#5665): this should take a trait object
-        writer: &'a mut MemWriter,
+        writer: @mut MemWriter,
         priv size_positions: ~[uint],
     }
 
-    fn write_sized_vuint(w: &mut MemWriter, n: uint, size: uint) {
+    impl Clone for Encoder {
+        fn clone(&self) -> Encoder {
+            Encoder {
+                writer: self.writer,
+                size_positions: self.size_positions.clone(),
+            }
+        }
+    }
+
+    fn write_sized_vuint(w: @mut MemWriter, n: uint, size: uint) {
         match size {
             1u => w.write(&[0x80u8 | (n as u8)]),
             2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
@@ -611,15 +620,15 @@ pub mod writer {
         };
     }
 
-    fn write_vuint(w: &mut MemWriter, n: uint) {
+    fn write_vuint(w: @mut MemWriter, n: uint) {
         if n < 0x7f_u { write_sized_vuint(w, n, 1u); return; }
         if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; }
         if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; }
         if n < 0x10000000_u { write_sized_vuint(w, n, 4u); return; }
         fail!("vint to write too big: {}", n);
     }
 
-    pub fn Encoder<'a>(w: &'a mut MemWriter) -> Encoder<'a> {
+    pub fn Encoder(w: @mut MemWriter) -> Encoder {
         let size_positions: ~[uint] = ~[];
         Encoder {
             writer: w,
@@ -628,15 +637,7 @@ pub mod writer {
     }
 
     // FIXME (#2741): Provide a function to write the standard ebml header.
-    impl<'a> Encoder<'a> {
-        /// XXX(pcwalton): Workaround for badness in trans. DO NOT USE ME.
-        pub unsafe fn unsafe_clone(&self) -> Encoder<'a> {
-            Encoder {
-                writer: cast::transmute_copy(&self.writer),
-                size_positions: self.size_positions.clone(),
-            }
-        }
-
+    impl Encoder {
         pub fn start_tag(&mut self, tag_id: uint) {
             debug!("Start tag {}", tag_id);
 
@@ -738,7 +739,7 @@ pub mod writer {
     // Totally lame approach.
     static DEBUG: bool = true;
 
-    impl<'a> Encoder<'a> {
+    impl Encoder {
         // used internally to emit things like the vector length and so on
         fn _emit_tagged_uint(&mut self, t: EbmlEncoderTag, v: uint) {
             assert!(v <= 0xFFFF_FFFF_u);
@@ -754,15 +755,17 @@ pub mod writer {
             // try and check failures more quickly.
             if DEBUG { self.wr_tagged_str(EsLabel as uint, label) }
         }
+    }
 
+    impl Encoder {
         pub fn emit_opaque(&mut self, f: |&mut Encoder|) {
             self.start_tag(EsOpaque as uint);
             f(self);
             self.end_tag();
         }
     }
 
-    impl<'a> ::serialize::Encoder for Encoder<'a> {
+    impl ::serialize::Encoder for Encoder {
         fn emit_nil(&mut self) {}
 
         fn emit_uint(&mut self, v: uint) {
@@ -817,7 +820,7 @@ pub mod writer {
             self.wr_tagged_str(EsStr as uint, v)
         }
 
-        fn emit_enum(&mut self, name: &str, f: |&mut Encoder<'a>|) {
+        fn emit_enum(&mut self, name: &str, f: |&mut Encoder|) {
             self._emit_label(name);
             self.start_tag(EsEnum as uint);
             f(self);
@@ -828,103 +831,98 @@ pub mod writer {
                              _: &str,
                              v_id: uint,
                              _: uint,
-                             f: |&mut Encoder<'a>|) {
+                             f: |&mut Encoder|) {
             self._emit_tagged_uint(EsEnumVid, v_id);
             self.start_tag(EsEnumBody as uint);
             f(self);
             self.end_tag();
         }
 
-        fn emit_enum_variant_arg(&mut self, _: uint, f: |&mut Encoder<'a>|) {
+        fn emit_enum_variant_arg(&mut self, _: uint, f: |&mut Encoder|) {
             f(self)
         }
 
         fn emit_enum_struct_variant(&mut self,
                                     v_name: &str,
                                     v_id: uint,
                                     cnt: uint,
-                                    f: |&mut Encoder<'a>|) {
+                                    f: |&mut Encoder|) {
             self.emit_enum_variant(v_name, v_id, cnt, f)
         }
 
         fn emit_enum_struct_variant_field(&mut self,
                                           _: &str,
                                           idx: uint,
-                                          f: |&mut Encoder<'a>|) {
+                                          f: |&mut Encoder|) {
             self.emit_enum_variant_arg(idx, f)
         }
 
-        fn emit_struct(&mut self,
-                       _: &str,
-                       _len: uint,
-                       f: |&mut Encoder<'a>|) {
+        fn emit_struct(&mut self, _: &str, _len: uint, f: |&mut Encoder|) {
             f(self)
         }
 
         fn emit_struct_field(&mut self,
                              name: &str,
                              _: uint,
-                             f: |&mut Encoder<'a>|) {
+                             f: |&mut Encoder|) {
             self._emit_label(name);
             f(self)
         }
 
-        fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'a>|) {
+        fn emit_tuple(&mut self, len: uint, f: |&mut Encoder|) {
             self.emit_seq(len, f)
         }
-        fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder<'a>|) {
+        fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder|) {
             self.emit_seq_elt(idx, f)
         }
 
         fn emit_tuple_struct(&mut self,
                              _: &str,
                              len: uint,
-                             f: |&mut Encoder<'a>|) {
+                             f: |&mut Encoder|) {
             self.emit_seq(len, f)
         }
-        fn emit_tuple_struct_arg(&mut self,
-                                 idx: uint,
-                                 f: |&mut Encoder<'a>|) {
+        fn emit_tuple_struct_arg(&mut self, idx: uint, f: |&mut Encoder|) {
             self.emit_seq_elt(idx, f)
         }
 
-        fn emit_option(&mut self, f: |&mut Encoder<'a>|) {
+        fn emit_option(&mut self, f: |&mut Encoder|) {
             self.emit_enum("Option", f);
         }
         fn emit_option_none(&mut self) {
             self.emit_enum_variant("None", 0, 0, |_| ())
         }
-        fn emit_option_some(&mut self, f: |&mut Encoder<'a>|) {
+        fn emit_option_some(&mut self, f: |&mut Encoder|) {
             self.emit_enum_variant("Some", 1, 1, f)
         }
 
-        fn emit_seq(&mut self, len: uint, f: |&mut Encoder<'a>|) {
+        fn emit_seq(&mut self, len: uint, f: |&mut Encoder|) {
             self.start_tag(EsVec as uint);
             self._emit_tagged_uint(EsVecLen, len);
             f(self);
             self.end_tag();
         }
 
-        fn emit_seq_elt(&mut self, _idx: uint, f: |&mut Encoder<'a>|) {
+        fn emit_seq_elt(&mut self, _idx: uint, f: |&mut Encoder|) {
             self.start_tag(EsVecElt as uint);
             f(self);
             self.end_tag();
         }
 
-        fn emit_map(&mut self, len: uint, f: |&mut Encoder<'a>|) {
+        fn emit_map(&mut self, len: uint, f: |&mut Encoder|) {
             self.start_tag(EsMap as uint);
             self._emit_tagged_uint(EsMapLen, len);
             f(self);
             self.end_tag();
         }
 
-        fn emit_map_elt_key(&mut self, _idx: uint, f: |&mut Encoder<'a>|) {
+        fn emit_map_elt_key(&mut self, _idx: uint, f: |&mut Encoder|) {
             self.start_tag(EsMapKey as uint);
             f(self);
             self.end_tag();
         }
 
-        fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'a>|) {
+        fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder|) {
             self.start_tag(EsMapVal as uint);
             f(self);
             self.end_tag();
@@ -950,11 +948,9 @@ mod tests {
     fn test_option_int() {
         fn test_v(v: Option<int>) {
             debug!("v == {:?}", v);
-            let mut wr = MemWriter::new();
-            {
-                let mut ebml_w = writer::Encoder(&mut wr);
-                v.encode(&mut ebml_w);
-            }
+            let wr = @mut MemWriter::new();
+            let mut ebml_w = writer::Encoder(wr);
+            v.encode(&mut ebml_w);
             let ebml_doc = reader::Doc(*wr.inner_ref());
             let mut deser = reader::Decoder(ebml_doc);
             let v1 = serialize::Decodable::decode(&mut deser);

branches/auto/src/libgreen/lib.rs

@@ -214,11 +214,7 @@ impl SchedPool {
             pool.handles.push(sched.make_handle());
             let sched = sched;
             pool.threads.push(do Thread::start {
-                let mut sched = sched;
-                let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                    rtdebug!("boostraping a non-primary scheduler");
-                };
-                sched.bootstrap(task);
+                sched.bootstrap();
             });
         }
 
@@ -270,13 +266,7 @@ impl SchedPool {
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
-        self.threads.push(do Thread::start {
-            let mut sched = sched;
-            let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                rtdebug!("boostraping a non-primary scheduler");
-            };
-            sched.bootstrap(task);
-        });
+        self.threads.push(do Thread::start { sched.bootstrap() });
 
         return ret;
     }

branches/auto/src/libgreen/sched.rs

@@ -171,7 +171,7 @@ impl Scheduler {
 
     // Take a main task to run, and a scheduler to run it in. Create a
     // scheduler task and bootstrap into it.
-    pub fn bootstrap(mut ~self, task: ~GreenTask) {
+    pub fn bootstrap(mut ~self) {
 
         // Build an Idle callback.
         let cb = ~SchedRunner as ~Callback;
@@ -187,18 +187,11 @@ impl Scheduler {
         self.idle_callback.get_mut_ref().resume();
 
         // Now, as far as all the scheduler state is concerned, we are inside
-        // the "scheduler" context. So we can act like the scheduler and resume
-        // the provided task. Let it think that the currently running task is
-        // actually the sched_task so it knows where to squirrel it away.
-        let mut sched_task = self.resume_task_immediately(sched_task, task);
-
-        // Now we are back in the scheduler context, having
-        // successfully run the input task. Start by running the
-        // scheduler. Grab it out of TLS - performing the scheduler
-        // action will have given it away.
-        let sched = sched_task.sched.take_unwrap();
-        rtdebug!("starting scheduler {}", sched.sched_id());
-        let mut sched_task = sched.run(sched_task);
+        // the "scheduler" context. The scheduler immediately hands over control
+        // to the event loop, and this will only exit once the event loop no
+        // longer has any references (handles or I/O objects).
+        rtdebug!("starting scheduler {}", self.sched_id());
+        let mut sched_task = self.run(sched_task);
 
         // Close the idle callback.
         let mut sched = sched_task.sched.take_unwrap();
@@ -548,7 +541,10 @@ impl Scheduler {
         // We push the task onto our local queue clone.
         assert!(!task.is_sched());
         self.work_queue.push(task);
-        self.idle_callback.get_mut_ref().resume();
+        match self.idle_callback {
+            Some(ref mut idle) => idle.resume(),
+            None => {} // allow enqueuing before the scheduler starts
+        }
 
         // We've made work available. Notify a
         // sleeping scheduler.
@@ -1176,25 +1172,21 @@ mod test {
                 let mut sh = special_handle;
                 sh.send(Shutdown);
             };
-
+            normal_sched.enqueue_task(normal_task);
 
             let special_task = do GreenTask::new(&mut special_sched.stack_pool,
                                                  None) {
                 run(task1);
                 run(task3);
                 chan.send(());
             };
-
+            special_sched.enqueue_task(special_task);
 
             let normal_sched = normal_sched;
-            let normal_thread = do Thread::start {
-                normal_sched.bootstrap(normal_task);
-            };
+            let normal_thread = do Thread::start { normal_sched.bootstrap() };
 
             let special_sched = special_sched;
-            let special_thread = do Thread::start {
-                special_sched.bootstrap(special_task);
-            };
+            let special_thread = do Thread::start { special_sched.bootstrap() };
 
             normal_thread.join();
             special_thread.join();

branches/auto/src/librustc/back/archive.rs

@@ -187,11 +187,7 @@ impl Archive {
 
         let mut rustpath = filesearch::rust_path();
         rustpath.push(self.sess.filesearch.get_target_lib_path());
-        let addl_lib_search_paths = self.sess
-                                        .opts
-                                        .addl_lib_search_paths
-                                        .borrow();
-        let path = addl_lib_search_paths.get().iter();
+        let path = self.sess.opts.addl_lib_search_paths.iter();
         for path in path.chain(rustpath.iter()) {
             debug!("looking for {} inside {}", name, path.display());
             let test = path.join(oslibname.as_slice());