Bitwise IO: Difference between revisions

language is Object Oriented and you prefer) for reading and writing sequences of

"S", "T", "R", "I", "N", "G", the output of a "print" of the bits sequence

0101011101010 (13 bits) must be 0101011101010; real I/O is performed always

* Limits in the maximum number of bits that can be written/read in a single read/write operation are allowed.

* Errors handling is not mandatory

 

=={{header|Ada}}==

with Ada.Finalization;

 

end record;

overriding procedure Finalize (Stream : in out Bit_Stream);

The package provides a bit stream interface to a conventional stream. The object of Bit_Stream has a discriminant of any stream type. This stream will be used for physical I/O. Bit_Stream reads and writes arrays of bits. There is no need to have flush procedure, because this is done upon object destruction. The implementation is straightforward, big endian encoding of bits into Stream_Element units is used as required by the task:

procedure Finalize (Stream : in out Bit_Stream) is

begin

end loop;

end Write;

Example of use:

with Bit_Streams; use Bit_Streams;

 

1,0,0,0,0,1,1, -- C

1,0,1,0,1,0,1, -- U

);

Data : Bit_Array (ABACUS'Range);

raise Data_Error;

end if;

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

MODE NIBBLE = STRUCT(INT width, BITS bits);

 

example uudecode nibble stream;

example uuencode nibble stream;

{{out}}

<pre>

STRING & ABACUS => 101001110101001010010100100110011101000111010000001001100100000100000110000101000001100001110101011010011

</pre>

=={{header|AutoHotkey}}==

IfExist, %A_WorkingDir%\z.dat

IfNotEqual ErrorLevel,0, MsgBox Can't delete file "%file%"`nErrorLevel = "%ErrorLevel%"

 

Totalread += 0 ; convert to original format

Return TotalRead

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

test$ = "Hello, world!"

v% = v% << 1 OR (a% >> c%) AND 1

ENDWHILE

{{out}}

<pre>

Hello, world!

</pre>

 

=={{header|C}}==

MSB in a byte is considered the "first" bit. Read and write methods somewhat mimic fread and fwrite, though there's no fflush-like function because flushing bits into a file is ill-defined (this whole task is pretty ill-defined). Only way to make sure all bits are written to the file is by detaching the bit filter, just like how closing a file flushes out buffer. There's no limit on read/write size, but caller should ensure the buffer is large enough.

#include <stdlib.h>

#include <stdint.h>

typedef uint8_t byte;

typedef struct {

} bit_io_t, *bit_filter;

 

bit_filter b_attach(FILE *f)

{

}

 

void b_write(byte *buf, size_t n_bits, size_t shift, bit_filter bf)

{

 

 

}

 

size_t b_read(byte *buf, size_t n_bits, size_t shift, bit_filter bf)

{

 

 

 

 

 

}

 

void b_detach(bit_filter bf)

{

}

 

int main()

{

 

 

 

 

 

=={{header|C sharp|C#}}==

using System.IO;

 

reader.Align();

}

 

=={{header|D}}==

{{trans|C}}

import core.stdc.stdio: FILE, fputc, fgetc;

import std.string: representation;

// Should be the same chars as 'data'.

result.assumeUTF.writeln;

{{out}}

abcdefghijk

 

=={{header|Erlang}}==

-compile([export_all]).

 

end,

Decompressed = decompress(Unpadded),

{{out}}

<<"Hello, Rosetta Code!">>: 160

<<145,151,102,205,235,16,82,223,207,47,78,152,80,67,223,147,42,1:4>>: 140

ok

185> bitwise_io:test_file_io().

=={{header|Forth}}==

The stream status is kept on the stack ( b m ), where b is the character accumulator

with the MSB. (The writing code was originally used for Mandelbrot generation.)

 

 

: init-write ( -- b m ) 0 128 ;

: read-bit ( b m -- b' m' f )

dup 0= if 2drop init-read then

 

=={{header|Haskell}}==

import Data.Char

import Control.Monad

putStrLn $ "Compressed text has " ++ show (length bits `div` 8) ++ " bytes."

putStrLn "Read and decompress:"

* 7-bits code has lsb leading.

<pre>*Main> :main ["This text is used to illustrate the Rosetta Code task 'bit oriented IO'."]

Read and decompress:

This text is used to illustrate the Rosetta Code task 'bit oriented IO'.</pre>

=={{header|J}}==

;Solution

;Usage

Do and undo bit oriented IO:

 

bitReader bitWriter text

Original text length:

Compressed length:

 

=={{header|OCaml}}==

The [http://code.google.com/p/ocaml-extlib/ extLib] provides [http://ocaml-extlib.googlecode.com/svn/doc/apiref/IO.html#6_BitsAPI bit oriented IO functions].

let oc = open_out filename in

let ob = IO.output_bits(IO.output_channel oc) in

IO.flush_bits ob;

close_out oc;

 

let ic = open_in filename in

let ib = IO.input_bits(IO.input_channel ic) in

done; ""

with IO.No_more_input ->

=={{header|Perl}}==

 

# $buffer = write_bits(*STDOUT, $buffer, $number, $bits)

{

my ($out, $l, $num, $q) = @_;

$l .= substr(unpack("B*", pack("N", $num)),

if ( (length($l) > 8) ) {

}

return $l;

 

# flush_bits(*STDOUT, $buffer)

{

my ($out, $b) = @_;

 

# ($val, $buf) = read_bits(*STDIN, $buf, $n)

{

my ( $in, $b, $n ) = @_;

if ( $n > 32 ) { return 0; }

while ( length($b) < $n ) {

}

my $bits = "0" x ( 32-$n ) . substr($b, 0, $n);

$b = substr($b, $n);

return ($val, $b);

''Crunching'' bytes discarding most significant bit (lossless compression for ASCII and few more!)

my $c;

while( read(*STDIN, $c, 1) > 0 ) {

$buf = write_bits(*STDOUT, $buf, unpack("C1", $c), 7);

}

Expanding each seven bits to fit a byte (padding the ''eight'' most significant bit with 0):

my $v;

while(1) {

last if ($buf < 0);

print pack("C1", $v);

 

{{out}}

 

=={{header|PL/I}}==

on endfile (sysin) go to ending;

bs = ''b;

bs = bs || copy('0'b, mod(length(bs), 8) );

/* pad length to a multiple of 8 */

Example:

<pre>

1010011101010010100101001001100111010001111010011000110100010100000000

</pre>

=={{header|PureBasic}}==

The bits are read/written with the HSB being read/written first, then each full byte (8 bits) is read/written in succession. Depending on the native integer size the compiler is using, upto 32-bits or 64-bits can be read/written at once. The procedure flushBits() should be called when the reading/writing of bits is completed. If a partial byte is written the bits containing data will begin with the HSB and the padding bits will end with the LSB.

 

As a slight speed modification, the readBits() and writeBits() procedures will attempt to write groups of bits whenever possible.

bitsToWrite.i

bitsToRead.i

result + "Expanded string = '" + testReadString + "'"

 

{{out}}

<pre>Original ascii string is 74 bytes.

The expanded string is the same as the original.

Expanded string = 'This is an ascii string that will be crunched, written, read and expanded.'</pre>

=={{header|Python}}==

def __init__(self, f):

self.accumulator = 0

self.bcount = 0

self.out = f

 

def __del__(self):

try:

self.flush()

pass

 

self.flush()

if bit > 0:

self.bcount += 1

 

def writebits(self, bits, n):

while n > 0:

n -= 1

 

def flush(self):

self.accumulator = 0

self.bcount = 0

 

 

def __init__(self, f):

self.input = f

self.read = 0

 

a = self.input.read(1)

self.accumulator = ord(a)

self.bcount = 8

self.read = len(a)

self.bcount -= 1

return rv

v = 0

while n > 0:

n -= 1

import bitio

 

while len(c) > 0:

o.writebits(ord(c), 7)

import bitio

 

while True:

x = r.readbits(7)

break

 

=={{header|REXX}}==

* 01.11.2012 Walter Pachl

***********************************************************************/

r=r||x2c(x) /* convert to character */

End /* and append to result */

{{out}}

<pre>

000000 padding

r=STRING

 

=={{header|Ruby}}==

{{trans|Tcl}}

{{works with|Ruby|1.8.7}}

bitstring = ascii.bytes.collect {|b| "%07b" % b}.join

[bitstring].pack("B*")

else

puts "fail!"

 

=={{header|Tcl}}==

 

proc crunch {ascii} {

} else {

error "not the same"

{{out}}

<pre>my ascii string is 74 bytes

the file containing the crunched text is 65 bytes

the expanded string is the same as the original</pre>

 

{{omit from|AWK|Traditional AWK has no bitwise operators}}

{{omit from|gnuplot}}