Now codgen works

src/main.rs

@@ -145,45 +145,66 @@ static CODED: [u32; 132] =
 ///
 /// Count the number of zeroes
 ///
-fn count_zero(num: u32) -> u32 {
+fn count_zero(mut num: u32) -> u32 {
 
-    let mut count_zero = 0;
-    let mut count_one = 0;
+    let mut n = 32;
 
-    for x in 0..32 {
-        if num % 2 == 0 {
-            count_zero += 1;
-        } else {
-            count_one += 1;
+    while num != 0 {
+        if num & 1u32 == 1u32 {
+            n -= 1;
         }
-        num << 1;
+        num >>= 1;
     }
-    count_zero ^ count_one
+    n
 }
 
 ///
 /// Modify the seed for decoding
 ///
+///
+///FUNCTION codgen(): UNSIGNED INTEGER;
+/// LOCAL SIGNED INTEGER   n;
+/// LOCAL UNSIGNED INTEGER x, y;
+/// BEGIN
+///   n := [count the number of 0's in word "seed"];
+///   x := [rotate "seed" left by 30 bits];
+///   y := [shift "seed" right-ARITHMETIC by 6 bits];
+///   seed := x XOR y XOR n;
+///  RETURN( seed XOR 0x464b713e );
+/// END;
 fn codgen(seed: &mut u32) -> u32 {
 
     let n: u32;
     let (x, y): (u32, u32);
 
-    n = count_zero(*seed);
+    let local_seed: u32 = seed.clone();
+
+
+    // Send away copy of seed
+    //n = count_zero(local_seed);
+    n = local_seed.count_zeros();
+
+    println!("Number of zeroes: {}", n);
 
-    println!("Seed:\n{:b}", *seed);
+    //println!("Seed:\n{:b}", local_seed);
     // Inte OK än
-    x = seed.rotate_left(2);
-    println!("{:b}", x);
+    x = local_seed.rotate_left(30);
+
+    // Stolen from K & H
+    //x = local_seed << 30 | ((local_seed>> 2) & 0x3FFFFFFF);
+
+    //println!("{:b}", x);
 
     // Fungerade fint
-    y = *seed >> 6;
+    // Shift 6 to the right arithmetic
+    // Needs to be i32 to be arithmetic, testing wrapping_shr
+    y = ((local_seed as i32) >> 6) as u32;
+    //y = local_seed.wrapping_shr(6);
 
-    *seed = x ^ y ^ n;
+    *seed = (x ^ y ^ n) as u32;
 
     (*seed) ^ 0x464b713e
 
-
 }
 
 ///
@@ -191,7 +212,6 @@ fn codgen(seed: &mut u32) -> u32 {
 ///
 fn decode(coded: &[u32], plain: &mut[u8], seed: &mut u32) -> u32 {
 
-
     let x = 3;
     x
 
@@ -204,29 +224,30 @@ fn main() {
     let mut seed = 0x3e944b9f;
 
     //decode(&CODED, unsafe { &mut PLAIN }, &mut seed);
-    //
-    codgen(&mut seed);
 
-    println!("Ran codgen, new seed: {:x}", seed);
+    let mut locseed;
+
+    locseed = codgen(&mut seed);
+    assert_eq!(locseed, 0x891432f9);
+    println!("Ran codgen, new seed: {:x}", locseed);
+    locseed = codgen(&mut seed);
+    println!("Ran codgen, new seed: {:x}", locseed);
+    locseed = codgen(&mut seed);
+    println!("Ran codgen, new seed: {:x}", locseed);
+    locseed = codgen(&mut seed);
+    println!("Ran codgen, new seed: {:x}", locseed);
+    locseed = codgen(&mut seed);
+    assert_eq!(locseed, 0xce83d1b8);
+    println!("Ran codgen, new seed: {:x}", locseed);
 
 }
+
 /*
 # Group 1's Codeword Generator Subroutine (pseudocode)
 #  (remember:  "seed" is a global variable, UNSIGNED INTEGER;
 #              you may implement local variables in registers or on the stack;
 #              result returned in v0; preserve all except t regs)
 # 
-# FUNCTION codgen(): UNSIGNED INTEGER;
-#  LOCAL SIGNED INTEGER   n;
-#  LOCAL UNSIGNED INTEGER x, y;
-#  BEGIN
-#    n := [count the number of 0's in word "seed"];
-#    x := [rotate "seed" left by 30 bits];
-#    y := [shift "seed" right-ARITHMETIC by 6 bits];
-#    seed := x XOR y XOR n;
-#   RETURN( seed XOR 0x464b713e );
-#  END;
-# 
 # hint:  if "seed" is initialized to 0x3e944b9f,
 #        the first five calls will generate these values:
 #        0x891432f9, 0x4aa1dccc, 0xc54270fa, 0x9885155f, 0xce83d1b8, ...