// Provides utility routine
// (rodric rabbah, <rabbah@mit.edu>)

// take stream of N bits and permute them accordingly to
// specified permutation table
bit->bit filter Permute(int N, int[N] permutation)
{
    work push N pop N {
        for (int i = 0; i < N; i++) {
            push(peek(permutation[i]));
        }
        for (int i = 0; i < N; i++) {
            pop();
        }
    }
}

// take N streams and Xor them together
// the streams are assumed to be interleaved
bit->bit filter Xor(int n)
{
    work push 1 pop n {
        bit x = pop();
        for (int i = 1; i < n; i++) {
            bit y = pop();
            x = x ^ y;
        }
		push(x);
    }
}

// input:  integer
// output: LSB first ... MSB last
int->bit filter IntoBits() 
{
  work pop 1 push 32 {
      int v = pop();
      int m = 1;

      for (int i = 0; i < 32; i++) {
          if (((v & m) >> i) != 0)
              push(1);
          else
              push(0);
          m = m << 1;
      }
  }
}

// input:  LSB first ... MSB last
// output: integer
bit->int filter BitstoInts(int n) 
{
    work peek n pop n push 1 {
        int v = 0;
        for (int i = 0; i < n; i++) {
            v = v | (pop() << i);
        }
        push(v);
    }
}

// input:  w words x b bits/word
// output: bit i from all w words, followed by i+1 for all b bits
bit->bit splitjoin BitSlice(int w, int b)
{
    split roundrobin(1);
    for (int l = 0; l < b; l++) {
        add Identity<bit>;
    }
    join roundrobin(w);
}

// input:  LSB first ... MSB last
// output: none
// prints: MSW first ... LSW last
bit->void pipeline HexPrinter(int descriptor, int n)
{
    int bits  = n;
    int bytes = bits / 4;
    
    add BitstoInts(4);
    add int->void filter {
        work pop bytes {
            if (PRINTINFO) {
                if (descriptor == PLAINTEXT) 
                    print("P: ");
                else if (descriptor == USERKEY)
                    print("K: ");
                else if (descriptor == CIPHERTEXT)
                    print("C: ");
            }

            for (int i = bytes - 1; i >= 0; i--) {
                int v = peek(i);
                if (v < 10) print(v);
                else if (v == 10) print("A");
                else if (v == 11) print("B");
                else if (v == 12) print("C");
                else if (v == 13) print("D");
                else if (v == 14) print("E");
                else if (v == 15) print("F");
                else {
                    print("ERROR: "); 
                    println(v);
                }
            }
            println("");

            for (int i = 0; i < bytes; i++) 
                pop();
        }
    }
}

// input:  LSB first ... MSB last
// output: LSB first ... MSB last
// prints: MSW first ... LSW last
bit->bit splitjoin ShowIntermediate(int n)
{
    int bits  = n;
    int bytes = bits / 4;

    split duplicate;
    add Identity<bit>;
    add pipeline {
        add BitstoInts(4);
        add int->void filter {
            work pop bytes {
                for (int i = bytes - 1; i >= 0; i--) {
                    int v = peek(i);
                    if (v < 10) print(v);
                    else if (v == 10) print("A");
                    else if (v == 11) print("B");
                    else if (v == 12) print("C");
                    else if (v == 13) print("D");
                    else if (v == 14) print("E");
                    else if (v == 15) print("F");
                    else {
                        print("ERROR: "); 
                        println(v);
                    }
                }
                println("");
                
                for (int i = 0; i < bytes; i++) 
                    pop();
            }
        }
    }
    join roundrobin(1, 0);
}