rollup merge of #20482: kmcallister/macro-reform

[rust.git] / src / librand / isaac.rs

diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
index 03b56963ba944e4229096bba33bdee12f39868b9..84328360ce32431e7b40f0ca582d2268ada3feee 100644 (file)
--- a/src/librand/isaac.rs
+++ b/src/librand/isaac.rs
@@ -69,7 +69,7 @@ fn init(&mut self, use_rsl: bool) {
         let mut g = a;
         let mut h = a;
 
-        macro_rules! mix(
+        macro_rules! mix {
             () => {{
                 a^=b<<11; d+=a; b+=c;
                 b^=c>>2;  e+=b; c+=d;
@@ -80,14 +80,14 @@ macro_rules! mix(
                 g^=h<<8;  b+=g; h+=a;
                 h^=a>>9;  c+=h; a+=b;
             }}
-        );
+        }
 
         for _ in range(0u, 4) {
             mix!();
         }
 
         if use_rsl {
-            macro_rules! memloop (
+            macro_rules! memloop {
                 ($arr:expr) => {{
                     for i in range_step(0, RAND_SIZE as uint, 8) {
                         a+=$arr[i  ]; b+=$arr[i+1];
@@ -101,7 +101,7 @@ macro_rules! memloop (
                         self.mem[i+6]=g; self.mem[i+7]=h;
                     }
                 }}
-            );
+            }
 
             memloop!(self.rsl);
             memloop!(self.mem);
@@ -129,41 +129,42 @@ fn isaac(&mut self) {
 
         static MIDPOINT: uint = (RAND_SIZE / 2) as uint;
 
-        macro_rules! ind (($x:expr) => {
-            self.mem[(($x >> 2) as uint & ((RAND_SIZE - 1) as uint))]
-        });
+        macro_rules! ind {
+            ($x:expr) => ( self.mem[(($x >> 2) as uint & ((RAND_SIZE - 1) as uint))] )
+        }
 
         let r = [(0, MIDPOINT), (MIDPOINT, 0)];
         for &(mr_offset, m2_offset) in r.iter() {
 
-            macro_rules! rngstepp(
+            macro_rules! rngstepp {
                 ($j:expr, $shift:expr) => {{
-                        let base = $j;
-                        let mix = a << $shift as uint;
+                    let base = $j;
+                    let mix = a << $shift as uint;
 
-                        let x = self.mem[base  + mr_offset];
-                        a = (a ^ mix) + self.mem[base + m2_offset];
-                        let y = ind!(x) + a + b;
-                        self.mem[base + mr_offset] = y;
+                    let x = self.mem[base  + mr_offset];
+                    a = (a ^ mix) + self.mem[base + m2_offset];
+                    let y = ind!(x) + a + b;
+                    self.mem[base + mr_offset] = y;
 
-                        b = ind!(y >> RAND_SIZE_LEN as uint) + x;
-                        self.rsl[base + mr_offset] = b;
-                    }}
-                );
-            macro_rules! rngstepn(
+                    b = ind!(y >> RAND_SIZE_LEN as uint) + x;
+                    self.rsl[base + mr_offset] = b;
+                }}
+            }
+
+            macro_rules! rngstepn {
                 ($j:expr, $shift:expr) => {{
-                        let base = $j;
-                        let mix = a >> $shift as uint;
+                    let base = $j;
+                    let mix = a >> $shift as uint;
 
-                        let x = self.mem[base  + mr_offset];
-                        a = (a ^ mix) + self.mem[base + m2_offset];
-                        let y = ind!(x) + a + b;
-                        self.mem[base + mr_offset] = y;
+                    let x = self.mem[base  + mr_offset];
+                    a = (a ^ mix) + self.mem[base + m2_offset];
+                    let y = ind!(x) + a + b;
+                    self.mem[base + mr_offset] = y;
 
-                        b = ind!(y >> RAND_SIZE_LEN as uint) + x;
-                        self.rsl[base + mr_offset] = b;
-                    }}
-                );
+                    b = ind!(y >> RAND_SIZE_LEN as uint) + x;
+                    self.rsl[base + mr_offset] = b;
+                }}
+            }
 
             for i in range_step(0u, MIDPOINT, 4) {
                 rngstepp!(i + 0, 13);
@@ -301,15 +302,15 @@ pub fn new_unseeded() -> Isaac64Rng {
     /// of `rsl` as a seed, otherwise construct one algorithmically (not
     /// randomly).
     fn init(&mut self, use_rsl: bool) {
-        macro_rules! init (
+        macro_rules! init {
             ($var:ident) => (
                 let mut $var = 0x9e3779b97f4a7c13;
             )
-        );
+        }
         init!(a); init!(b); init!(c); init!(d);
         init!(e); init!(f); init!(g); init!(h);
 
-        macro_rules! mix(
+        macro_rules! mix {
             () => {{
                 a-=e; f^=h>>9;  h+=a;
                 b-=f; g^=a<<9;  a+=b;
@@ -320,14 +321,14 @@ macro_rules! mix(
                 g-=c; d^=f>>17; f+=g;
                 h-=d; e^=g<<14; g+=h;
             }}
-        );
+        }
 
         for _ in range(0u, 4) {
             mix!();
         }
 
         if use_rsl {
-            macro_rules! memloop (
+            macro_rules! memloop {
                 ($arr:expr) => {{
                     for i in range(0, RAND_SIZE_64 / 8).map(|i| i * 8) {
                         a+=$arr[i  ]; b+=$arr[i+1];
@@ -341,7 +342,7 @@ macro_rules! memloop (
                         self.mem[i+6]=g; self.mem[i+7]=h;
                     }
                 }}
-            );
+            }
 
             memloop!(self.rsl);
             memloop!(self.mem);
@@ -366,49 +367,51 @@ fn isaac64(&mut self) {
         let mut b = self.b + self.c;
         const MIDPOINT: uint =  RAND_SIZE_64 / 2;
         const MP_VEC: [(uint, uint); 2] = [(0,MIDPOINT), (MIDPOINT, 0)];
-        macro_rules! ind (
+        macro_rules! ind {
             ($x:expr) => {
                 *self.mem.get_unchecked(($x as uint >> 3) & (RAND_SIZE_64 - 1))
             }
-        );
+        }
 
         for &(mr_offset, m2_offset) in MP_VEC.iter() {
             for base in range(0, MIDPOINT / 4).map(|i| i * 4) {
 
-                macro_rules! rngstepp(
+                macro_rules! rngstepp {
                     ($j:expr, $shift:expr) => {{
-                            let base = base + $j;
-                            let mix = a ^ (a << $shift as uint);
-                            let mix = if $j == 0 {!mix} else {mix};
-
-                            unsafe {
-                                let x = *self.mem.get_unchecked(base + mr_offset);
-                                a = mix + *self.mem.get_unchecked(base + m2_offset);
-                                let y = ind!(x) + a + b;
-                                *self.mem.get_unchecked_mut(base + mr_offset) = y;
-
-                                b = ind!(y >> RAND_SIZE_64_LEN) + x;
-                                *self.rsl.get_unchecked_mut(base + mr_offset) = b;
-                            }
-                        }}
-                    );
-                macro_rules! rngstepn(
+                        let base = base + $j;
+                        let mix = a ^ (a << $shift as uint);
+                        let mix = if $j == 0 {!mix} else {mix};
+
+                        unsafe {
+                            let x = *self.mem.get_unchecked(base + mr_offset);
+                            a = mix + *self.mem.get_unchecked(base + m2_offset);
+                            let y = ind!(x) + a + b;
+                            *self.mem.get_unchecked_mut(base + mr_offset) = y;
+
+                            b = ind!(y >> RAND_SIZE_64_LEN) + x;
+                            *self.rsl.get_unchecked_mut(base + mr_offset) = b;
+                        }
+                    }}
+                }
+
+                macro_rules! rngstepn {
                     ($j:expr, $shift:expr) => {{
-                            let base = base + $j;
-                            let mix = a ^ (a >> $shift as uint);
-                            let mix = if $j == 0 {!mix} else {mix};
-
-                            unsafe {
-                                let x = *self.mem.get_unchecked(base + mr_offset);
-                                a = mix + *self.mem.get_unchecked(base + m2_offset);
-                                let y = ind!(x) + a + b;
-                                *self.mem.get_unchecked_mut(base + mr_offset) = y;
-
-                                b = ind!(y >> RAND_SIZE_64_LEN) + x;
-                                *self.rsl.get_unchecked_mut(base + mr_offset) = b;
-                            }
-                        }}
-                    );
+                        let base = base + $j;
+                        let mix = a ^ (a >> $shift as uint);
+                        let mix = if $j == 0 {!mix} else {mix};
+
+                        unsafe {
+                            let x = *self.mem.get_unchecked(base + mr_offset);
+                            a = mix + *self.mem.get_unchecked(base + m2_offset);
+                            let y = ind!(x) + a + b;
+                            *self.mem.get_unchecked_mut(base + mr_offset) = y;
+
+                            b = ind!(y >> RAND_SIZE_64_LEN) + x;
+                            *self.rsl.get_unchecked_mut(base + mr_offset) = b;
+                        }
+                    }}
+                }
+
                 rngstepp!(0u, 21);
                 rngstepn!(1u, 5);
                 rngstepp!(2u, 12);