Ranges must use ... instead of ..

Author: drbawb

src/encoding/codec/japanese.rs

@@ -50,10 +50,10 @@ impl Encoder for EUCJPEncoder {
 
         for ((i,j), ch) in input.index_iter() {
             match ch {
-                '\u0000'..'\u007f' => { output.write_byte(ch as u8); }
+                '\u0000'...'\u007f' => { output.write_byte(ch as u8); }
                 '\u00a5' => { output.write_byte(0x5c); }
                 '\u203e' => { output.write_byte(0x7e); }
-                '\uff61'..'\uff9f' => {
+                '\uff61'...'\uff9f' => {
                     output.write_byte(0x8e);
                     output.write_byte((ch as uint - 0xff61 + 0xa1) as u8);
                 }
@@ -93,7 +93,7 @@ ascii_compatible_stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0xa1..0xfe, 0xa1..0xfe) => (lead - 0xa1) * 94 + trail - 0xa1,
+            (0xa1...0xfe, 0xa1...0xfe) => (lead - 0xa1) * 94 + trail - 0xa1,
             _ => 0xffff,
         };
         index::jis0208::forward(index as u16)
@@ -105,39 +105,39 @@ ascii_compatible_stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0xa1..0xfe, 0xa1..0xfe) => (lead - 0xa1) * 94 + trail - 0xa1,
+            (0xa1...0xfe, 0xa1...0xfe) => (lead - 0xa1) * 94 + trail - 0xa1,
             _ => 0xffff,
         };
         index::jis0212::forward(index as u16)
     }
 
     // euc-jp lead = 0x00
     initial state S0(ctx) {
-        case b @ 0x00..0x7f => ctx.emit(b as u32);
+        case b @ 0x00...0x7f => ctx.emit(b as u32);
         case 0x8e => S1(ctx);
         case 0x8f => S2(ctx);
-        case b @ 0xa1..0xfe => S3(ctx, b);
+        case b @ 0xa1...0xfe => S3(ctx, b);
         case _ => ctx.err("invalid sequence");
     }
 
     // euc-jp lead = 0x8e
     state S1(ctx) {
-        case b @ 0xa1..0xdf => ctx.emit(0xff61 + b as u32 - 0xa1);
-        case 0xa1..0xfe => ctx.err("invalid sequence");
+        case b @ 0xa1...0xdf => ctx.emit(0xff61 + b as u32 - 0xa1);
+        case 0xa1...0xfe => ctx.err("invalid sequence");
         case _ => ctx.backup_and_err(1, "invalid sequence");
     }
 
     // euc-jp lead = 0x8f
     // JIS X 0201 half-width katakana
     state S2(ctx) {
-        case b @ 0xa1..0xfe => S4(ctx, b);
+        case b @ 0xa1...0xfe => S4(ctx, b);
         case _ => ctx.backup_and_err(1, "invalid sequence");
     }
 
     // euc-jp lead != 0x00, euc-jp jis0212 flag = unset
     // JIS X 0208 two-byte sequence
     state S3(ctx, lead: u8) {
-        case b @ 0xa1..0xfe => match map_two_0208_bytes(lead, b) {
+        case b @ 0xa1...0xfe => match map_two_0208_bytes(lead, b) {
             // do NOT backup, we only backup for out-of-range trails.
             0xffff => ctx.err("invalid sequence"),
             ch => ctx.emit(ch as u32)
@@ -148,7 +148,7 @@ ascii_compatible_stateful_decoder! {
     // euc-jp lead != 0x00, euc-jp jis0212 flag = set
     // JIS X 0212 three-byte sequence
     state S4(ctx, lead: u8) {
-        case b @ 0xa1..0xfe => match map_two_0212_bytes(lead, b) {
+        case b @ 0xa1...0xfe => match map_two_0212_bytes(lead, b) {
             // do NOT backup, we only backup for out-of-range trails.
             0xffff => ctx.err("invalid sequence"),
             ch => ctx.emit(ch as u32)
@@ -443,10 +443,10 @@ impl Encoder for Windows31JEncoder {
 
         for ((i,j), ch) in input.index_iter() {
             match ch {
-                '\u0000'..'\u0080' => { output.write_byte(ch as u8); }
+                '\u0000'...'\u0080' => { output.write_byte(ch as u8); }
                 '\u00a5' => { output.write_byte(0x5c); }
                 '\u203e' => { output.write_byte(0x7e); }
-                '\uff61'..'\uff9f' => { output.write_byte((ch as uint - 0xff61 + 0xa1) as u8); }
+                '\uff61'...'\uff9f' => { output.write_byte((ch as uint - 0xff61 + 0xa1) as u8); }
                 _ => {
                     // corresponds to the "index shift_jis pointer" in the WHATWG spec
                     let ptr = index::jis0208::backward_remapped(ch as u32);
@@ -488,10 +488,10 @@ ascii_compatible_stateful_decoder! {
         let leadoffset = if lead < 0xa0 {0x81} else {0xc1};
         let trailoffset = if trail < 0x7f {0x40} else {0x41};
         let index = match (lead, trail) {
-            (0xf0..0xf9, 0x40..0x7e) | (0xf0..0xf9, 0x80..0xfc) =>
+            (0xf0...0xf9, 0x40...0x7e) | (0xf0...0xf9, 0x80...0xfc) =>
                 return (0xe000 + (lead - 0xf0) * 188 + trail - trailoffset) as u32,
-            (0x81..0x9f, 0x40..0x7e) | (0x81..0x9f, 0x80..0xfc) |
-            (0xe0..0xfc, 0x40..0x7e) | (0xe0..0xfc, 0x80..0xfc) =>
+            (0x81...0x9f, 0x40...0x7e) | (0x81...0x9f, 0x80...0xfc) |
+            (0xe0...0xfc, 0x40...0x7e) | (0xe0...0xfc, 0x80...0xfc) =>
                 (lead - leadoffset) * 188 + trail - trailoffset,
             _ => 0xffff,
         };
@@ -500,9 +500,9 @@ ascii_compatible_stateful_decoder! {
 
     // shift_jis lead = 0x00
     initial state S0(ctx) {
-        case b @ 0x00..0x80 => ctx.emit(b as u32);
-        case b @ 0xa1..0xdf => ctx.emit(0xff61 + b as u32 - 0xa1);
-        case b @ 0x81..0x9f | b @ 0xe0..0xfc => S1(ctx, b);
+        case b @ 0x00...0x80 => ctx.emit(b as u32);
+        case b @ 0xa1...0xdf => ctx.emit(0xff61 + b as u32 - 0xa1);
+        case b @ 0x81...0x9f | b @ 0xe0...0xfc => S1(ctx, b);
         case _ => ctx.err("invalid sequence");
     }
 
@@ -758,10 +758,10 @@ impl Encoder for ISO2022JPEncoder {
 
         for ((i,j), ch) in input.index_iter() {
             match ch {
-                '\u0000'..'\u007f' => { ensure_ASCII!(); output.write_byte(ch as u8); }
+                '\u0000'...'\u007f' => { ensure_ASCII!(); output.write_byte(ch as u8); }
                 '\u00a5' => { ensure_ASCII!(); output.write_byte(0x5c); }
                 '\u203e' => { ensure_ASCII!(); output.write_byte(0x7e); }
-                '\uff61'..'\uff9f' => {
+                '\uff61'...'\uff9f' => {
                     ensure_Katakana!();
                     output.write_byte((ch as uint - 0xff61 + 0x21) as u8);
                 }
@@ -807,7 +807,7 @@ stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x21..0x7e, 0x21..0x7e) => (lead - 0x21) * 94 + trail - 0x21,
+            (0x21...0x7e, 0x21...0x7e) => (lead - 0x21) * 94 + trail - 0x21,
             _ => 0xffff,
         };
         index::jis0208::forward(index as u16)
@@ -819,7 +819,7 @@ stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x21..0x7e, 0x21..0x7e) => (lead - 0x21) * 94 + trail - 0x21,
+            (0x21...0x7e, 0x21...0x7e) => (lead - 0x21) * 94 + trail - 0x21,
             _ => 0xffff,
         };
         index::jis0212::forward(index as u16)
@@ -828,7 +828,7 @@ stateful_decoder! {
     // iso-2022-jp state = ASCII, iso-2022-jp jis0212 flag = unset, iso-2022-jp lead = 0x00
     initial state ASCII(ctx) {
         case 0x1b => EscapeStart(ctx);
-        case b @ 0x00..0x7f => ctx.emit(b as u32), ASCII(ctx);
+        case b @ 0x00...0x7f => ctx.emit(b as u32), ASCII(ctx);
         case _ => ctx.err("invalid sequence"), ASCII(ctx);
         final => ctx.reset();
     }
@@ -852,7 +852,7 @@ stateful_decoder! {
     // iso-2022-jp state = Katakana
     checkpoint state Katakana(ctx) {
         case 0x1b => EscapeStart(ctx);
-        case b @ 0x21..0x5f => ctx.emit(0xff61 + b as u32 - 0x21), Katakana(ctx);
+        case b @ 0x21...0x5f => ctx.emit(0xff61 + b as u32 - 0x21), Katakana(ctx);
         case _ => ctx.err("invalid sequence"), Katakana(ctx);
         final => ctx.reset();
     }

src/encoding/codec/korean.rs

@@ -89,13 +89,13 @@ ascii_compatible_stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x81..0xc6, 0x41..0x5a) =>
+            (0x81...0xc6, 0x41...0x5a) =>
                 (26 + 26 + 126) * (lead - 0x81) + trail - 0x41,
-            (0x81..0xc6, 0x61..0x7a) =>
+            (0x81...0xc6, 0x61...0x7a) =>
                 (26 + 26 + 126) * (lead - 0x81) + 26 + trail - 0x61,
-            (0x81..0xc6, 0x81..0xfe) =>
+            (0x81...0xc6, 0x81...0xfe) =>
                 (26 + 26 + 126) * (lead - 0x81) + 26 + 26 + trail - 0x81,
-            (0xc7..0xfe, 0xa1..0xfe) =>
+            (0xc7...0xfe, 0xa1...0xfe) =>
                 (26 + 26 + 126) * (0xc7 - 0x81) + (lead - 0xc7) * 94 + trail - 0xa1,
             (_, _) => 0xffff,
         };
@@ -104,8 +104,8 @@ ascii_compatible_stateful_decoder! {
 
     // euc-kr lead = 0x00
     initial state S0(ctx) {
-        case b @ 0x00..0x7f => ctx.emit(b as u32);
-        case b @ 0x81..0xfe => S1(ctx, b);
+        case b @ 0x00...0x7f => ctx.emit(b as u32);
+        case b @ 0x81...0xfe => S1(ctx, b);
         case _ => ctx.err("invalid sequence");
     }
 

src/encoding/codec/simpchinese.rs

@@ -101,7 +101,7 @@ ascii_compatible_stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x81..0xfe, 0x40..0x7e) | (0x81..0xfe, 0x80..0xfe) => {
+            (0x81...0xfe, 0x40...0x7e) | (0x81...0xfe, 0x80...0xfe) => {
                 let trailoffset = if trail < 0x7f {0x40} else {0x41};
                 (lead - 0x81) * 190 + trail - trailoffset
             }
@@ -121,15 +121,15 @@ ascii_compatible_stateful_decoder! {
 
     // gb18030 first = 0x00, gb18030 second = 0x00, gb18030 third = 0x00
     initial state S0(ctx) {
-        case b @ 0x00..0x7f => ctx.emit(b as u32);
+        case b @ 0x00...0x7f => ctx.emit(b as u32);
         case 0x80 => ctx.emit(0x20ac);
-        case b @ 0x81..0xfe => S1(ctx, b);
+        case b @ 0x81...0xfe => S1(ctx, b);
         case _ => ctx.err("invalid sequence");
     }
 
     // gb18030 first != 0x00, gb18030 second = 0x00, gb18030 third = 0x00
     state S1(ctx, first: u8) {
-        case b @ 0x30..0x39 => S2(ctx, first, b);
+        case b @ 0x30...0x39 => S2(ctx, first, b);
         case b => match map_two_bytes(first, b) {
             0xffff => ctx.backup_and_err(1, "invalid sequence"), // unconditional
             ch => ctx.emit(ch)
@@ -138,13 +138,13 @@ ascii_compatible_stateful_decoder! {
 
     // gb18030 first != 0x00, gb18030 second != 0x00, gb18030 third = 0x00
     state S2(ctx, first: u8, second: u8) {
-        case b @ 0x81..0xfe => S3(ctx, first, second, b);
+        case b @ 0x81...0xfe => S3(ctx, first, second, b);
         case _ => ctx.backup_and_err(2, "invalid sequence");
     }
 
     // gb18030 first != 0x00, gb18030 second != 0x00, gb18030 third != 0x00
     state S3(ctx, first: u8, second: u8, third: u8) {
-        case b @ 0x30..0x39 => match map_four_bytes(first, second, third, b) {
+        case b @ 0x30...0x39 => match map_four_bytes(first, second, third, b) {
             0xffffffff => ctx.backup_and_err(3, "invalid sequence"), // unconditional
             ch => ctx.emit(ch)
         };
@@ -418,7 +418,7 @@ stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x20..0x7f, 0x21..0x7e) => (lead - 1) * 190 + (trail + 0x3f),
+            (0x20...0x7f, 0x21...0x7e) => (lead - 1) * 190 + (trail + 0x3f),
             _ => 0xffff,
         };
         index::gb18030::forward(index as u16)
@@ -427,15 +427,15 @@ stateful_decoder! {
     // hz-gb-2312 flag = unset, hz-gb-2312 lead = 0x00
     initial state A0(ctx) {
         case 0x7e => A1(ctx);
-        case b @ 0x00..0x7f => ctx.emit(b as u32);
+        case b @ 0x00...0x7f => ctx.emit(b as u32);
         case _ => ctx.err("invalid sequence");
         final => ctx.reset();
     }
 
     // hz-gb-2312 flag = set, hz-gb-2312 lead = 0x00
     checkpoint state B0(ctx) {
         case 0x7e => B1(ctx);
-        case b @ 0x20..0x7f => B2(ctx, b);
+        case b @ 0x20...0x7f => B2(ctx, b);
         case 0x0a => ctx.err("invalid sequence"); // error *and* reset
         case _ => ctx.err("invalid sequence"), B0(ctx);
         final => ctx.reset();

src/encoding/codec/tradchinese.rs

@@ -86,7 +86,7 @@ ascii_compatible_stateful_decoder! {
         let lead = lead as uint;
         let trail = trail as uint;
         let index = match (lead, trail) {
-            (0x81..0xfe, 0x40..0x7e) | (0x81..0xfe, 0xa1..0xfe) => {
+            (0x81...0xfe, 0x40...0x7e) | (0x81...0xfe, 0xa1...0xfe) => {
                 let trailoffset = if trail < 0x7f {0x40} else {0x62};
                 (lead - 0x81) * 157 + trail - trailoffset
             }
@@ -97,8 +97,8 @@ ascii_compatible_stateful_decoder! {
 
     // big5 lead = 0x00
     initial state S0(ctx) {
-        case b @ 0x00..0x7f => ctx.emit(b as u32);
-        case b @ 0x81..0xfe => S1(ctx, b);
+        case b @ 0x00...0x7f => ctx.emit(b as u32);
+        case b @ 0x81...0xfe => S1(ctx, b);
         case _ => ctx.err("invalid sequence");
     }
 

src/encoding/codec/utf_16.rs

@@ -110,10 +110,10 @@ impl<E:Endian+Clone+'static> Encoder for UTF16Encoder<E> {
         for ((i,j), ch) in input.index_iter() {
             let ch = ch as uint;
             match ch {
-                0x0000..0xd7ff | 0xe000..0xffff => {
+                0x0000...0xd7ff | 0xe000...0xffff => {
                     write_two_bytes(output, (ch >> 8) as u8, (ch & 0xff) as u8);
                 }
-                0x10000..0x10ffff => {
+                0x10000...0x10ffff => {
                     let ch = ch - 0x10000;
                     write_two_bytes(output, (0xd8 | (ch >> 18)) as u8,
                                             ((ch >> 10) & 0xff) as u8);
@@ -177,7 +177,7 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
                 let upper = self.leadsurrogate;
                 self.leadsurrogate = 0xffff;
                 match ch {
-                    0xdc00..0xdfff => {
+                    0xdc00...0xdfff => {
                         let ch = ((upper as uint - 0xd800) << 10) + (ch as uint - 0xdc00);
                         output.write_char(as_char(ch + 0x10000));
                         processed = i;
@@ -190,11 +190,11 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
                 }
             } else {
                 match ch {
-                    0xd800..0xdbff => {
+                    0xd800...0xdbff => {
                         self.leadsurrogate = ch;
                         // pass through
                     }
-                    0xdc00..0xdfff => {
+                    0xdc00...0xdfff => {
                         return (processed, Some(CodecError {
                             upto: i as int, cause: "invalid sequence".into_maybe_owned()
                         }));
@@ -218,7 +218,7 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
             let ch = concat_two_bytes(input[i-1] as u16, input[i]);
             i += 1;
             match ch {
-                0xdc00..0xdfff => {
+                0xdc00...0xdfff => {
                     let ch = ((upper as uint - 0xd800) << 10) + (ch as uint - 0xdc00);
                     output.write_char(as_char(ch + 0x10000));
                 }
@@ -243,7 +243,7 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
             }
             let ch = concat_two_bytes(input[i-1] as u16, input[i]);
             match ch {
-                0xd800..0xdbff => {
+                0xd800...0xdbff => {
                     i += 2;
                     if i >= len {
                         self.leadsurrogate = ch;
@@ -252,7 +252,7 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
                     }
                     let ch2 = concat_two_bytes(input[i-1] as u16, input[i]);
                     match ch2 {
-                        0xdc00..0xdfff => {
+                        0xdc00...0xdfff => {
                             let ch = ((ch as uint - 0xd800) << 10) + (ch2 as uint - 0xdc00);
                             output.write_char(as_char(ch + 0x10000));
                         }
@@ -263,7 +263,7 @@ impl<E:Endian+Clone+'static> Decoder for UTF16Decoder<E> {
                         }
                     }
                 }
-                0xdc00..0xdfff => {
+                0xdc00...0xdfff => {
                     return (processed, Some(CodecError {
                         upto: i as int + 1, cause: "invalid sequence".into_maybe_owned()
                     }));