Implement pattern ranges for all numeric types.

src/comp/util/common.rs

@@ -84,6 +84,162 @@ fn local_rhs_span(l: @ast::local, def: span) -> span {
     alt l.node.init { some(i) { ret i.expr.span; } _ { ret def; } }
 }
 
+fn lit_is_numeric(l: @ast::lit) -> bool {
+    alt l.node {
+      ast::lit_int(_) | ast::lit_char(_) | ast::lit_uint(_) |
+      ast::lit_mach_int(_, _) | ast::lit_float(_) | ast::lit_mach_float(_,_) {
+        true
+      }
+      _ { false }
+    }
+}
+
+fn lit_type_eq(l: @ast::lit, m: @ast::lit) -> bool {
+    alt l.node {
+      ast::lit_str(_) {
+        alt m.node { ast::lit_str(_) { true } _ { false } }
+      }
+      ast::lit_char(_) {
+        alt m.node { ast::lit_char(_) { true } _ { false } }
+      }
+      ast::lit_int(_) {
+        alt m.node { ast::lit_int(_) { true } _ { false } }
+      }
+      ast::lit_uint(_) {
+        alt m.node { ast::lit_uint(_) { true } _ { false } }
+      }
+      ast::lit_mach_int(_, _) {
+        alt m.node { ast::lit_mach_int(_, _) { true } _ { false } }
+      }
+      ast::lit_float(_) {
+        alt m.node { ast::lit_float(_) { true } _ { false } }
+      }
+      ast::lit_mach_float(_, _) {
+        alt m.node { ast::lit_mach_float(_, _) { true } _ { false } }
+      }
+      ast::lit_nil. {
+        alt m.node { ast::lit_nil. { true } _ { false } }
+      }
+      ast::lit_bool(_) {
+        alt m.node { ast::lit_bool(_) { true } _ { false } }
+      }
+    }
+}
+
+fn lit_in_range(l: @ast::lit, m1: @ast::lit, m2: @ast::lit) -> bool {
+    alt lits_to_range(m1, m2) {
+      irange(i1, i2) {
+        alt l.node {
+          ast::lit_int(i3) | ast::lit_mach_int(_, i3) {
+            i3 >= *min(i1, i2) && i3 <= *max(i1, i2)
+          }
+          _ { fail }
+        }
+      }
+      urange(u1, u2) {
+        alt l.node {
+          ast::lit_uint(u3) {
+            u3 >= *min(u1, u2) && u3 <= *max(u1, u2)
+          }
+          _ { fail }
+        }
+      }
+      crange(c1, c2) {
+        alt l.node {
+          ast::lit_char(c3) {
+            (c3 as uint) >= *min(c1 as uint, c2 as uint) &&
+            (c3 as uint) <= *max(c1 as uint, c2 as uint)
+          }
+          _ { fail }
+        }
+      }
+      frange(f1, f2) {
+        alt l.node {
+          ast::lit_float(f3) | ast::lit_mach_float(_, f3) {
+            str_to_float(f3) >= *min(f1, f2) &&
+            str_to_float(f3) <= *max(f1, f2)
+          }
+          _ { fail }
+        }
+      }
+    }
+}
+
+fn min<T>(x: T, y: T) -> @T {
+    ret @(if x > y { y } else { x });
+}
+
+fn max<T>(x: T, y: T) -> @T {
+    ret @(if x > y { x } else { y });
+}
+
+fn ranges_overlap<T>(a1: T, a2: T, b1: T, b2: T) -> bool {
+    let min1 = *min(a1, a2);
+    let max1 = *max(a1, a2);
+    let min2 = *min(b1, b2);
+    let max2 = *max(b1, b2);
+    ret (min1 >= min2 && max1 <= max2) || (min1 <= min2 && max1 >= min2) ||
+        (min1 >= min2 && min1 <= max2) || (max1 >= min2 && max1 <= max2);
+}
+
+fn lit_ranges_overlap(a1: @ast::lit, a2: @ast::lit,
+                      b1: @ast::lit, b2: @ast::lit) -> bool {
+    alt lits_to_range(a1, a2) {
+      irange(i1, i2) {
+        alt lits_to_range(b1, b2) {
+          irange(i3, i4) { ranges_overlap(i1, i2, i3, i4) }
+          _ { fail }
+        }
+      }
+      urange(u1, u2) {
+        alt lits_to_range(b1, b2) {
+          urange(u3, u4) { ranges_overlap(u1, u2, u3, u4) }
+          _ { fail }
+        }
+      }
+      crange(c1, c2) {
+        alt lits_to_range(b1, b2) {
+          crange(c3, c4) { ranges_overlap(c1, c2, c3, c4) }
+          _ { fail }
+        }
+      }
+      frange(f1, f2) {
+        alt lits_to_range(b1, b2) {
+          frange(f3, f4) { ranges_overlap(f1, f2, f3, f4) }
+          _ { fail }
+        }
+      }
+    }
+}
+
+tag range {
+    irange(int, int);
+    urange(uint, uint);
+    crange(char, char);
+    frange(float, float);
+}
+
+fn lits_to_range(l: @ast::lit, r: @ast::lit) -> range {
+    alt l.node {
+      ast::lit_int(i1) | ast::lit_mach_int(_, i1) {
+        alt r.node { ast::lit_int(i2) { irange(i1, i2) } _ { fail } }
+      }
+      ast::lit_uint(u1) {
+        alt r.node { ast::lit_uint(u2) { urange(u1, u2) } _ { fail } }
+      }
+      ast::lit_char(c1) {
+        alt r.node { ast::lit_char(c2) { crange(c1, c2) } _ { fail } }
+      }
+      ast::lit_float(f1) | ast::lit_mach_float(_, f1) {
+        alt r.node { ast::lit_float(f2) | ast::lit_mach_float(_, f2) {
+          frange(str_to_float(f1), str_to_float(f2))
+        }
+        _ { fail } }
+      }
+      _ { fail }
+    }
+}
+
 fn lit_eq(l: @ast::lit, m: @ast::lit) -> bool {
     alt l.node {
       ast::lit_str(s) {
@@ -156,6 +312,22 @@ fn float_to_str(num: float, digits: uint) -> str {
     ret accum;
 }
 
+fn str_to_float(num: str) -> float {
+    let digits = str::split(num, '.' as u8);
+    let total = int::from_str(digits[0]) as float;
+
+    fn dec_val(c: char) -> int { ret (c as int) - ('0' as int); }
+
+    let right = digits[1];
+    let len = str::char_len(digits[1]);
+    let i = 1u;
+    while (i < len) {
+        total += dec_val(str::pop_char(right)) as float /
+                 (int::pow(10, i) as float);
+        i += 1u;
+    }
+    ret total;
+}
 
 //
 // Local Variables: