Richard Fairhurst <richard / systemed.net> writes:

> I'm trying to write these opcode by opcode, and get a bytestream out the
> end of it. Currently I'm just appending each opcode to a long string
> (m+='00111'), and when it comes to writing it out, splitting this every
> eight characters and converting back to a single character. But this is
> awfully slow.
>
> Can anyone suggest a faster way?

How are you going from your string of 0s and 1s to bytes?

Might I suggest that the fastest way to do that part of the job is
this?

outstring = [m].pack("B*")

That'll pack things the way you seem to want them, and it'll
appropriately null-pad the last byte.

If you want to crunch 0s and 1s into bytes as you're building up your
opcode string, one possibility is to add this into whatever loop it is
that is appending opcodes:

while m.length > 40 do
  outstring += [m.slice!(0...40)].pack("B*")
end

That pulls bytes off m five bytes at a time.  The goal is to try to
strike a balance between letting m get too large (which makes
manipulating it in memory slightly slower) and letting pack - written
in C - do its job efficiently.  (pack is going to be more efficient
the larger the input)

You'll still need to at the very end do
  outstring += [m].pack("B*")
to get the remainder.

You can experiment with how much to pull off of m at a time to see
what value makes your particular program fastest.  For your purposes,
you may well find that the fastest solution is to not do any
0s-and-1s-to-bytes operations in your loop, and simply use pack at the
end.

-- 
s=%q(  Daniel Martin -- martin / snowplow.org
       puts "s=%q(#{s})",s.to_a.last       )
       puts "s=%q(#{s})",s.to_a.last