I think that you are going about this in a too C-ish manner. Whenever I encounter a problem where Perl seems to be getting in the way, I tend to find that I'm using the wrong method and by looking around, there is a perlish method or function that addresses the problem.

In this case, you need vec.

#! perl -slw
use strict;

sub xformBits {
    my( $in ) = shift;
    my $out = chr(0) x length( $in );
    vec($out,$_,1) = vec($in,7-int($_/8)+8*(7-$_%8),1) for 0..63;
    return $out;
}

my $example = 'ABCDEFGH';

print "Input: $example";
print join ' ', split'', unpack 'B8', $_ for split '', $example;

my $xformed = xformBits $example;

print "\nOutput: $xformed";
print join ' ', split'', unpack 'B8', $_ for split '', $xformed;

__END__
[12:12:24.25] P:\test>414344
Input: ABCDEFGH
0 1 0 0 0 0 0 1
0 1 0 0 0 0 1 0
0 1 0 0 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 0 0 1 0 1
0 1 0 0 0 1 1 0
0 1 0 0 0 1 1 1
0 1 0 0 1 0 0 0

Output:     ??f¬
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1
0 0 0 1 1 1 1 0
0 1 1 0 0 1 1 0
1 0 1 0 1 0 1 0

[12:12:49.51] P:\test>
[download]

Hooray! Yes, vec() was the function I was looking for, indeed. This will avoid the bitstring solution altogether, something which nearly everyone has recommended to me up to this point.

Thank you, BrowserUk, for restoring my faith and showing me the light. I was beginning to wonder if I would have to wait until perl6 (and hope that it included stronger typing in this fashion..) I'll work on the C-ish thinking, as well.

Off to check perldelta to see when vec() arrived...

Cheers,
-Jason

Update: another way:

sub transpose {
    return if length $_[0] < $BUFSIZE;
    pack"B*",join"",(split//,unpack"B*",substr$_[0],0,$BUFSIZE)[map$_%
+$BUFSIZE*$BUFSIZE+int($_/$BUFSIZE),0..$BUFSIZE**2-1]
}
[download]

Yes, my mistake on the transpose function with no return value. I have updated it correctly. I had trimmed it down to avoid warlording and posting a million lines of irrelevant code, and inadvertently chopped the return line as well :)

Anyway, the pack/unpack method above converts to a bitstring, then back again, does it not? Using a sequence of ascii '1's and '0's was precisely what I was trying to avoid... and I *know* perl can accomplish this task in that way. But, that method increases the memory requirements of the implementation eight-fold, adds internal conversion overhead, and doesn't fall into the design requirements of the original question :>

I hope this isn't misconstrued, but remember, this function has to transpose *every* $BUFSIZE bytes, and quickly, with low memory requirements, to be able to sit at the position in the protocol stack that it does.

Thanks,
Jason

I'm not sure what you are saying; does your original example work for you but is not fast enough?

I see you have return $out now, but I don't see you setting $out.

Update: I reread your original post and now see where you talk about trying to avoid the very kind of approach you present there. But I don't see where the trampling you describe comes into it. Do see BrowserUk's suggestion of using vec, which is perl's builtin way of dealing with data by bits without conversion.

I have already written a reference implementation in C that met with great success.

Then why not use Inline::C to include it in your module.