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

* Errors handling is not mandatory

<br><br>

 

=={{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|Common Lisp}}==

 

Common Lisp already has tonnes of bitwise-I/O functionality (remember, folks have written operating systems in Lisp …); in particular, READ-SEQUENCE and WRITE-SEQUENCE neatly handle dumping (VECTOR (UNSIGNED-BYTE 8)) objects directly to/from I/O streams with :ELEMENT-TYPE (UNSIGNED-BYTE 8). This is a fairly robust but not very optimized toolkit that shows off changing between vectors of bytes, vectors of characters, and bit-vectors in a few ways.

 

(defpackage :rosetta.bitwise-i/o

(:use :common-lisp)

(finish-output *trace-output*))

 

{{out}}

BITWISE-I/O> (bitwise-i/o-demo)

 

 

⇒ ABORT

=={{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|Go}}==

encoder and decoder internal types

(with LZW specific stuff trimmed).

package bit

 

import (

)

 

 

const (

)

 

 

type writer interface {

}

 

// Writer implements bit-wise writing to an io.Writer.

type Writer struct {

}

 

// writeLSB writes `width` bits of `c` in LSB order.

func (w *Writer) writeLSB(c uint32, width uint) error {

}

 

// writeMSB writes `width` bits of `c` in MSB order.

func (w *Writer) writeMSB(c uint32, width uint) error {

}

 

// WriteBits writes up to 16 bits of `c` to the underlying writer.

// Even for MSB ordering the bits are taken from the lower bits of `c`.

func (w *Writer) WriteBits(c uint16, width uint) error {

}

 

// It does not close the underlying writer.

func (w *Writer) Close() error {

 

}

 

// NewWriter returns a new bit Writer that writes completed bytes to `w`.

func NewWriter(w io.Writer, order Order) *Writer {

}

 

// Reader implements bit-wise reading from an io.Reader.

type Reader struct {

}

 

func (r *Reader) readLSB(width uint) (uint16, error) {

}

 

func (r *Reader) readMSB(width uint) (uint16, error) {

}

 

// ReadBits reads up to 16 bits from the underlying reader.

func (r *Reader) ReadBits(width uint) (uint16, error) {

}

 

// It does not close the underlying reader.

func (r *Reader) Close() error {

}

 

// NewReader returns a new bit Reader that reads bytes from `r`.

func NewReader(r io.Reader, order Order) *Reader {

And a test file (such as <code>bit_test.go</code>):

 

import (

)

 

func ExampleWriter_WriteBits() {

}

 

func Example() {

 

 

With this test file, running <code>go test -v</code> will compile the package and run the example verifying the output is as listed above in the <code>// Output:</code> comments.

(here the first goes with the <code>WriteBits</code> method and the later with the package documentation).

=={{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:

Note: '#' here counts the number of items in its right argument. (In some other languages, # marks the beginning of an in-line comment. J is not one of those languages. Also note that J's command prompt is three spaces. This makes copy&paste easier to use with previously issued commands.)

 

Compressed length:

Note: this implementation writes the bytes to the session (which is to say, it just gets displayed like any other result. Also, the compressed result is represented as bits - like 1 0 1 0 1... You'll of course need other code when you want to do other things.)

 

=={{header|Kotlin}}==

{{trans|C}}

 

import java.io.File

bf.closeReader()

println(String(s2, Charsets.UTF_8))

 

{{out}}

abcdefghijk

</pre>

=={{header|Lingo}}==

A "BitArray" class can be implemented by sub-classing ByteArray and extending it with methods that allow to get/set individual bits:

 

property ancestor

delete the last char of res

return res

 

Simple compression/decompression functions for 7-bit ASCII strings:

-- @param {string} str - ASCII string

-- @return {instance} BitArray

end repeat

return str

 

ba = crunchASCII(str)

 

 

put decrunchASCII(ba)

 

=={{header|MIPS Assembly}}==

See [[Bitwise IO/MIPS Assembly]]

=={{header|Nim}}==

 

BitWriter * = tuple

file: File

 

result = 0

if stream.nRemain == 0:

stream.nRead = stream.file.readBuffer(stream.bits.addr, 1)

 

assert((dataCtr and 0x7f).uint8 == aByte)

 

assert(dataCtr == 256)

file.close

 

=={{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}}==

This following code works in both Python 2 & 3. Suggested module file name <tt>bitio.py</tt>.

def __init__(self, f):

self.accumulator = 0

chars.append(chr(x))

print(''.join(chars))

Another usage example showing how to "crunch" an 8-bit byte ASCII stream discarding the most significant "unused" bit...and read it back.

import bitio

 

c = sys.stdin.read(1)

o.flush()

...and to "decrunch" the same stream:

import bitio

 

if not r.read: # nothing read

break

=={{header|Racket}}==

 

#lang racket

 

(printf "Decrunched string ~aequal to original.\n"

(if (equal? orig (decrunch "crunched.out")) "" "NOT "))

 

{{out}}

Decrunched string equal to original.

</pre>

 

=={{header|REXX}}==

===version 1===

* 01.11.2012 Walter Pachl

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

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

End /* and append to result */

{{out}}

<pre>

 

===version 2===

say ' input string=' $ /*display the input string to terminal.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

decoded string= STRING

</pre>

=={{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>

 

=={{header|zkl}}==

This code implements two state machines: one that transforms a bit stream (ie a stream of ints with a maximum number of bits) to a byte stream and one does the reverse transform. All streams are considered infinite (eg a file or socket).

 

Bits to bytes:

fcn toBytes(n,[(numBits,acc,bitsSoFar)]state){

acc=acc.shiftLeft(numBits) + n; bitsSoFar+=numBits;

state.clear(numBits,acc,bitsSoFar);

r

Encode a stream of 6 bit characters:

ns.println(ns.len());

 

cns:=ns.pump(List,toBytes.fp1(state)); // List could be a file or socket or ...

if(state[2]) cns+=toBytes(0,state); // flush

{{out}}

<pre>

</pre>

Byte stream to bit stream:

fcn fromBytes(n,[(numBits,acc,bitsSoFar,buf)]state){

acc=acc.shiftLeft(8) + n; bitsSoFar+=8;

state.clear(numBits,acc,bitsSoFar,buf);

return(Void.Write,Void.Write,buf); // append contents of buf to result

Decode the above stream:

r:=cns.pump(List,fromBytes.fp1(state)); // cns could be a file or ...

r.println(r.len());

{{out}}

<pre>

THIS IS A TEST

</pre>

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

{{omit from|gnuplot}}