---

yaml
---
r: 112874
b: refs/heads/auto
c: dbea485
h: refs/heads/master
v: v3

Author: adrientetar

[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: a3f9f37014c77cda1ae53bf0984190e877aa413a
+refs/heads/auto: dbea4853a97ff7bc2e7a25f41be6c49b7dc6e960
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libregex/compile.rs

@@ -13,6 +13,7 @@
 #![allow(visible_private_types)]
 
 use std::cmp;
+use std::iter;
 use parse;
 use parse::{
     Flags, FLAG_EMPTY,
@@ -88,7 +89,7 @@ pub struct Program {
 
 impl Program {
     /// Compiles a Regex given its AST.
-    pub fn new(ast: parse::Ast) -> (Program, Vec<Option<~str>>) {
+    pub fn new(ast: ~parse::Ast) -> (Program, ~[Option<~str>]) {
         let mut c = Compiler {
             insts: Vec::with_capacity(100),
             names: Vec::with_capacity(10),
@@ -103,16 +104,16 @@ impl Program {
         // This is a bit hacky since we have to skip over the initial
         // 'Save' instruction.
         let mut pre = StrBuf::with_capacity(5);
-        for inst in c.insts.slice_from(1).iter() {
-            match *inst {
+        for i in iter::range(1, c.insts.len()) {
+            match *c.insts.get(i) {
                 OneChar(c, FLAG_EMPTY) => pre.push_char(c),
                 _ => break
             }
         }
 
-        let Compiler { insts, names } = c;
+        let names = c.names.as_slice().into_owned();
         let prog = Program {
-            insts: insts,
+            insts: c.insts,
             prefix: pre.into_owned(),
         };
         (prog, names)
@@ -143,48 +144,48 @@ struct Compiler<'r> {
 // The only tricky thing here is patching jump/split instructions to point to
 // the right instruction.
 impl<'r> Compiler<'r> {
-    fn compile(&mut self, ast: parse::Ast) {
+    fn compile(&mut self, ast: ~parse::Ast) {
         match ast {
-            Nothing => {},
-            Literal(c, flags) => self.push(OneChar(c, flags)),
-            Dot(nl) => self.push(Any(nl)),
-            Class(ranges, flags) =>
+            ~Nothing => {},
+            ~Literal(c, flags) => self.push(OneChar(c, flags)),
+            ~Dot(nl) => self.push(Any(nl)),
+            ~Class(ranges, flags) =>
                 self.push(CharClass(ranges, flags)),
-            Begin(flags) => self.push(EmptyBegin(flags)),
-            End(flags) => self.push(EmptyEnd(flags)),
-            WordBoundary(flags) => self.push(EmptyWordBoundary(flags)),
-            Capture(cap, name, x) => {
+            ~Begin(flags) => self.push(EmptyBegin(flags)),
+            ~End(flags) => self.push(EmptyEnd(flags)),
+            ~WordBoundary(flags) => self.push(EmptyWordBoundary(flags)),
+            ~Capture(cap, name, x) => {
                 let len = self.names.len();
                 if cap >= len {
                     self.names.grow(10 + cap - len, &None)
                 }
                 *self.names.get_mut(cap) = name;
 
                 self.push(Save(2 * cap));
-                self.compile(*x);
+                self.compile(x);
                 self.push(Save(2 * cap + 1));
             }
-            Cat(xs) => {
+            ~Cat(xs) => {
                 for x in xs.move_iter() {
                     self.compile(x)
                 }
             }
-            Alt(x, y) => {
+            ~Alt(x, y) => {
                 let split = self.empty_split(); // push: split 0, 0
                 let j1 = self.insts.len();
-                self.compile(*x);                // push: insts for x
+                self.compile(x);                // push: insts for x
                 let jmp = self.empty_jump();    // push: jmp 0
                 let j2 = self.insts.len();
-                self.compile(*y);                // push: insts for y
+                self.compile(y);                // push: insts for y
                 let j3 = self.insts.len();
 
                 self.set_split(split, j1, j2);  // split 0, 0 -> split j1, j2
                 self.set_jump(jmp, j3);         // jmp 0      -> jmp j3
             }
-            Rep(x, ZeroOne, g) => {
+            ~Rep(x, ZeroOne, g) => {
                 let split = self.empty_split();
                 let j1 = self.insts.len();
-                self.compile(*x);
+                self.compile(x);
                 let j2 = self.insts.len();
 
                 if g.is_greedy() {
@@ -193,11 +194,11 @@ impl<'r> Compiler<'r> {
                     self.set_split(split, j2, j1);
                 }
             }
-            Rep(x, ZeroMore, g) => {
+            ~Rep(x, ZeroMore, g) => {
                 let j1 = self.insts.len();
                 let split = self.empty_split();
                 let j2 = self.insts.len();
-                self.compile(*x);
+                self.compile(x);
                 let jmp = self.empty_jump();
                 let j3 = self.insts.len();
 
@@ -208,9 +209,9 @@ impl<'r> Compiler<'r> {
                     self.set_split(split, j3, j2);
                 }
             }
-            Rep(x, OneMore, g) => {
+            ~Rep(x, OneMore, g) => {
                 let j1 = self.insts.len();
-                self.compile(*x);
+                self.compile(x);
                 let split = self.empty_split();
                 let j2 = self.insts.len();
 

branches/auto/src/libregex/lib.rs

@@ -362,7 +362,7 @@
        html_root_url = "http://static.rust-lang.org/doc/master")]
 
 #![feature(macro_rules, phase)]
-#![deny(missing_doc, deprecated_owned_vector)]
+#![deny(missing_doc)]
 
 extern crate collections;
 #[cfg(test)]