---

yaml
---
r: 80685
b: refs/heads/try
c: ef08b23
h: refs/heads/master
i:
  80683: f49dc72
v: v3

Author: Dretch

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 7f0d261ae2d931a8a3e06d784840d85e25166d89
+refs/heads/try: ef08b2339db40b12b7061da1b18a406fd1b94983
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/glob.rs

@@ -147,8 +147,14 @@ enum PatternToken {
     Char(char),
     AnyChar,
     AnySequence,
-    AnyWithin(~[char]),
-    AnyExcept(~[char])
+    AnyWithin(~[CharSpecifier]),
+    AnyExcept(~[CharSpecifier])
+}
+
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
+enum CharSpecifier {
+    SingleChar(char),
+    CharRange(char, char)
 }
 
 #[deriving(Eq)]
@@ -164,12 +170,15 @@ impl Pattern {
      * This function compiles Unix shell style patterns: `?` matches any single character,
      * `*` matches any (possibly empty) sequence of characters and `[...]` matches any character
      * inside the brackets, unless the first character is `!` in which case it matches any
-     * character except those between the `!` and the `]`.
+     * character except those between the `!` and the `]`. Character sequences can also specify
+     * ranges of characters, as ordered by Unicode, so e.g. `[0-9]` specifies any character
+     * between 0 and 9 inclusive.
      *
      * The metacharacters `?`, `*`, `[`, `]` can be matched by using brackets (e.g. `[?]`).
      * When a `]` occurs immediately following `[` or `[!` then it is interpreted as
      * being part of, rather then ending, the character set, so `]` and NOT `]` can be
-     * matched by `[]]` and `[!]]` respectively.
+     * matched by `[]]` and `[!]]` respectively. The `-` character can be specified inside a
+     * character sequence pattern by placing it at the start or the end, e.g. `[abc-]`.
      *
      * When a `[` does not have a closing `]` before the end of the string then the `[` will
      * be treated literally.
@@ -199,7 +208,8 @@ impl Pattern {
                         match chars.slice_from(i + 3).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                tokens.push(AnyExcept(chars.slice(i + 2, i + 3 + j).to_owned()));
+                                let cs = parse_char_specifiers(chars.slice(i + 2, i + 3 + j));
+                                tokens.push(AnyExcept(cs));
                                 i += j + 4;
                                 loop;
                             }
@@ -209,7 +219,8 @@ impl Pattern {
                         match chars.slice_from(i + 2).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                tokens.push(AnyWithin(chars.slice(i + 1, i + 2 + j).to_owned()));
+                                let cs = parse_char_specifiers(chars.slice(i + 1, i + 2 + j));
+                                tokens.push(AnyWithin(cs));
                                 i += j + 3;
                                 loop;
                             }
@@ -335,15 +346,11 @@ impl Pattern {
                         AnyChar => {
                             !require_literal(c)
                         }
-                        AnyWithin(ref chars) => {
-                            !require_literal(c) &&
-                            chars.iter()
-                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_some()
+                        AnyWithin(ref specifiers) => {
+                            !require_literal(c) && in_char_specifiers(*specifiers, c, options)
                         }
-                        AnyExcept(ref chars) => {
-                            !require_literal(c) &&
-                            chars.iter()
-                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_none()
+                        AnyExcept(ref specifiers) => {
+                            !require_literal(c) && !in_char_specifiers(*specifiers, c, options)
                         }
                         Char(c2) => {
                             chars_eq(c, c2, options.case_sensitive)
@@ -370,6 +377,63 @@ impl Pattern {
 
 }
 
+fn parse_char_specifiers(s: &[char]) -> ~[CharSpecifier] {
+    let mut cs = ~[];
+    let mut i = 0;
+    while i < s.len() {
+        if i + 3 <= s.len() && s[i + 1] == '-' {
+            cs.push(CharRange(s[i], s[i + 2]));
+            i += 3;
+        } else {
+            cs.push(SingleChar(s[i]));
+            i += 1;
+        }
+    }
+    cs
+}
+
+fn in_char_specifiers(specifiers: &[CharSpecifier], c: char, options: MatchOptions) -> bool {
+
+    for &specifier in specifiers.iter() {
+        match specifier {
+            SingleChar(sc) => {
+                if chars_eq(c, sc, options.case_sensitive) {
+                    return true;
+                }
+            }
+            CharRange(start, end) => {
+
+                // FIXME: work with non-ascii chars properly (issue #1347)
+                if !options.case_sensitive && c.is_ascii() && start.is_ascii() && end.is_ascii() {
+
+                    let start = start.to_ascii().to_lower();
+                    let end = end.to_ascii().to_lower();
+
+                    let start_up = start.to_upper();
+                    let end_up = end.to_upper();
+
+                    // only allow case insensitive matching when
+                    // both start and end are within a-z or A-Z
+                    if start != start_up && end != end_up {
+                        let start = start.to_char();
+                        let end = end.to_char();
+                        let c = c.to_ascii().to_lower().to_char();
+                        if c >= start && c <= end {
+                            return true;
+                        }
+                    }
+                }
+
+                if c >= start && c <= end {
+                    return true;
+                }
+            }
+        }
+    }
+
+    false
+}
+
 /// A helper function to determine if two chars are (possibly case-insensitively) equal.
 fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool {
     if cfg!(windows) && path::windows::is_sep(a) && path::windows::is_sep(b) {
@@ -672,6 +736,54 @@ mod test {
         glob("/*/*/*/*").skip(10000).next();
     }
 
+    #[test]
+    fn test_range_pattern() {
+
+        let pat = Pattern::new("a[0-9]b");
+        for i in range(0, 10) {
+            assert!(pat.matches(fmt!("a%db", i)));
+        }
+        assert!(!pat.matches("a_b"));
+
+        let pat = Pattern::new("a[!0-9]b");
+        for i in range(0, 10) {
+            assert!(!pat.matches(fmt!("a%db", i)));
+        }
+        assert!(pat.matches("a_b"));
+
+        let pats = ["[a-z123]", "[1a-z23]", "[123a-z]"];
+        for &p in pats.iter() {
+            let pat = Pattern::new(p);
+            for c in "abcdefghijklmnopqrstuvwxyz".iter() {
+                assert!(pat.matches(c.to_str()));
+            }
+            for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ".iter() {
+                let options = MatchOptions {case_sensitive: false, .. MatchOptions::new()};
+                assert!(pat.matches_with(c.to_str(), options));
+            }
+            assert!(pat.matches("1"));
+            assert!(pat.matches("2"));
+            assert!(pat.matches("3"));
+        }
+
+        let pats = ["[abc-]", "[-abc]", "[a-c-]"];
+        for &p in pats.iter() {
+            let pat = Pattern::new(p);
+            assert!(pat.matches("a"));
+            assert!(pat.matches("b"));
+            assert!(pat.matches("c"));
+            assert!(pat.matches("-"));
+            assert!(!pat.matches("d"));
+        }
+
+        let pat = Pattern::new("[2-1]");
+        assert!(!pat.matches("1"));
+        assert!(!pat.matches("2"));
+
+        assert!(Pattern::new("[-]").matches("-"));
+        assert!(!Pattern::new("[!-]").matches("-"));
+    }
+
     #[test]
     fn test_unclosed_bracket() {
         // unclosed `[` should be treated literally

branches/try/src/librustc/metadata/decoder.rs

@@ -115,8 +115,7 @@ enum Family {
     Mod,                   // m
     ForeignMod,            // n
     Enum,                  // t
-    TupleVariant,          // v
-    StructVariant,         // V
+    Variant,               // v
     Impl,                  // i
     Trait,                 // I
     Struct,                // S
@@ -140,8 +139,7 @@ fn item_family(item: ebml::Doc) -> Family {
       'm' => Mod,
       'n' => ForeignMod,
       't' => Enum,
-      'v' => TupleVariant,
-      'V' => StructVariant,
+      'v' => Variant,
       'i' => Impl,
       'I' => Trait,
       'S' => Struct,
@@ -363,13 +361,9 @@ fn item_to_def_like(item: ebml::Doc, did: ast::DefId, cnum: ast::CrateNum)
         Type | ForeignType => DlDef(ast::DefTy(did)),
         Mod => DlDef(ast::DefMod(did)),
         ForeignMod => DlDef(ast::DefForeignMod(did)),
-        StructVariant => {
+        Variant => {
             let enum_did = item_reqd_and_translated_parent_item(cnum, item);
-            DlDef(ast::DefVariant(enum_did, did, true))
-        }
-        TupleVariant => {
-            let enum_did = item_reqd_and_translated_parent_item(cnum, item);
-            DlDef(ast::DefVariant(enum_did, did, false))
+            DlDef(ast::DefVariant(enum_did, did))
         }
         Trait => DlDef(ast::DefTrait(did)),
         Enum => DlDef(ast::DefTy(did)),
@@ -581,8 +575,8 @@ impl<'self> EachItemContext<'self> {
                 }
                 ImmStatic | MutStatic | Struct | UnsafeFn | Fn | ForeignFn |
                 UnsafeStaticMethod | StaticMethod | Type | ForeignType |
-                TupleVariant | StructVariant | Enum | PublicField |
-                PrivateField | InheritedField => {}
+                Variant | Enum | PublicField | PrivateField |
+                InheritedField => {}
             }
         }
 
@@ -1274,8 +1268,7 @@ fn item_family_to_str(fam: Family) -> ~str {
       Mod => ~"mod",
       ForeignMod => ~"foreign mod",
       Enum => ~"enum",
-      StructVariant => ~"struct variant",
-      TupleVariant => ~"tuple variant",
+      Variant => ~"variant",
       Impl => ~"impl",
       Trait => ~"trait",
       Struct => ~"struct",

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

@@ -307,27 +307,6 @@ fn encode_parent_item(ebml_w: &mut writer::Encoder, id: DefId) {
     ebml_w.end_tag();
 }
 
-fn encode_struct_fields(ecx: &EncodeContext,
-                             ebml_w: &mut writer::Encoder,
-                             def: @struct_def) {
-    for f in def.fields.iter() {
-        match f.node.kind {
-            named_field(ident, vis) => {
-               ebml_w.start_tag(tag_item_field);
-               encode_struct_field_family(ebml_w, vis);
-               encode_name(ecx, ebml_w, ident);
-               encode_def_id(ebml_w, local_def(f.node.id));
-               ebml_w.end_tag();
-            }
-            unnamed_field => {
-                ebml_w.start_tag(tag_item_unnamed_field);
-                encode_def_id(ebml_w, local_def(f.node.id));
-                ebml_w.end_tag();
-            }
-        }
-    }
-}
-
 fn encode_enum_variant_info(ecx: &EncodeContext,
                             ebml_w: &mut writer::Encoder,
                             id: NodeId,
@@ -347,10 +326,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
                           pos: ebml_w.writer.tell()});
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, def_id);
-        match variant.node.kind {
-            ast::tuple_variant_kind(_) => encode_family(ebml_w, 'v'),
-            ast::struct_variant_kind(_) => encode_family(ebml_w, 'V')
-        }
+        encode_family(ebml_w, 'v');
         encode_name(ecx, ebml_w, variant.node.name);
         encode_parent_item(ebml_w, local_def(id));
         encode_visibility(ebml_w, variant.node.vis);
@@ -360,14 +336,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
                     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(def) => {
-                let idx = encode_info_for_struct(ecx, ebml_w, path,
-                                         def.fields, index);
-                encode_struct_fields(ecx, ebml_w, def);
-                let bkts = create_index(idx);
-                encode_index(ebml_w, bkts, write_i64);
-            }
+            ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) => {}
         }
         if vi[i].disr_val != disr_val {
             encode_disr_val(ecx, ebml_w, vi[i].disr_val);
@@ -1017,7 +986,22 @@ fn encode_info_for_item(ecx: &EncodeContext,
         /* Encode def_ids for each field and method
          for methods, write all the stuff get_trait_method
         needs to know*/
-        encode_struct_fields(ecx, ebml_w, struct_def);
+        for f in struct_def.fields.iter() {
+            match f.node.kind {
+                named_field(ident, vis) => {
+                   ebml_w.start_tag(tag_item_field);
+                   encode_struct_field_family(ebml_w, vis);
+                   encode_name(ecx, ebml_w, ident);
+                   encode_def_id(ebml_w, local_def(f.node.id));
+                   ebml_w.end_tag();
+                }
+                unnamed_field => {
+                    ebml_w.start_tag(tag_item_unnamed_field);
+                    encode_def_id(ebml_w, local_def(f.node.id));
+                    ebml_w.end_tag();
+                }
+            }
+        }
 
         // Encode inherent implementations for this structure.
         encode_inherent_implementations(ecx, ebml_w, def_id);

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

@@ -396,8 +396,8 @@ impl tr for ast::Def {
           ast::DefStatic(did, m) => { ast::DefStatic(did.tr(xcx), m) }
           ast::DefArg(nid, b) => { ast::DefArg(xcx.tr_id(nid), b) }
           ast::DefLocal(nid, b) => { ast::DefLocal(xcx.tr_id(nid), b) }
-          ast::DefVariant(e_did, v_did, is_s) => {
-            ast::DefVariant(e_did.tr(xcx), v_did.tr(xcx), is_s)
+          ast::DefVariant(e_did, v_did) => {
+            ast::DefVariant(e_did.tr(xcx), v_did.tr(xcx))
           },
           ast::DefTrait(did) => ast::DefTrait(did.tr(xcx)),
           ast::DefTy(did) => ast::DefTy(did.tr(xcx)),

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

@@ -149,7 +149,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
             match def_map.find(&e.id) {
               Some(&DefStatic(*)) |
               Some(&DefFn(_, _)) |
-              Some(&DefVariant(_, _, _)) |
+              Some(&DefVariant(_, _)) |
               Some(&DefStruct(_)) => { }
 
               Some(&def) => {