Bitwise IO: Difference between revisions

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

bits, most significant bit first. While the output of a <tt>asciiprint "STRING"</tt> is the ASCII byte sequence

* Errors handling is not mandatory

<br><br>

=={{header|6502 Assembly}}==

This routine converts a byte to a sequence of ASCII zeroes and ones, and stores them in a null-terminated string. Works in Easy6502.

define z_BC $00 ;fake Z80-style register for pseudo-16-bit operations.

define z_C $00 ;6502 uses the low byte as the reference point for indirect lookups.

lda #$00 ;load the null terminator

sta (z_BC),y ;store the null terminator after the string

 

{{out}}

</pre>

 

 

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

 

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

FileDelete %file%

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>

 

return 0;

 

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

using System.IO;

 

reader.Align();

}

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

{{libheader| System.Classes}}

{{Trans|C#}}

program Bitwise_IO;

 

reader.Free;

Readln;

{{out}}

<pre>

0x0155

</pre>

 

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

 

}

return br

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

 

import (

// Written bytes: A9 A3 4F 34 1A 79 A0 C2 83 A6 5E 7D 17 00

// Read back as "This is a test."

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.

Additionally, <code>godoc -ex</code> will extract the code comments for documentation and include the examples at the appropriate place

(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|Julia}}==

ASCII 7-bit character string compression and decompression, to demonstrate bit twiddling. Implemented as generic IO, so that file handles are usable with the same functions.

function compress7(inio, outio)

nextwritebyte = read(inio, UInt8) & 0x7f

println("Compressed to length $(length(outs.data)) on line below:\n", String(outs.data))

println("Decompressed string: ", String(newouts.data))

Initial string of length 88: These bit oriented I/O functions can be used to implement compressors and decompressors.

Compressed to length 77 on line below:

Decompressed string: These bit oriented I/O functions can be used to implement compressors and decompressors.

</pre>

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

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) = @_;

 

# flush_bits(*STDOUT, $buffer)

{

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

 

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

{

my ( $in, $b, $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);

 

=={{header|Phix}}==

{{out}}

<pre>

simply ignore retrieved zero bytes, but that could fairly obviously create problems for some forms of binary data. A better solution

might be for the data to embed or prefix it's own length. The other four (commented-out) test values do not exhibit this problem.

=={{header|PicoLisp}}==

(let (Bits 0 Byte)

(for N Lst

(setq Byte (& 127 (>> (- Bits 7) N))) ) )

(when (= 7 Bits)

(hd 'a)

(in 'a (println (read7bitwise)))

(out 'a (write7bitwise (mapcar char (chop "STRING"))))

(hd 'a)

{{out}}

<pre>00000000 FE 03 F8 0F E0 3F 80 FE .....?..

00000000 A7 52 94 99 D1 C0 .R....

("S" "T" "R" "I" "N" "G")</pre>

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

(formerly Perl 6)

my @b = flat $s.ords».fmt("%07b")».comb;

@b.push(0) until @b %% 8; # padding

}

say my $encode = encode-ascii 'STRING';

{{out}}

<pre>Buf:0x<03 8b 99 29 4a e5>

STRING</pre>

=={{header|Red}}==

Title: "Bitwise IO"

Link: http://rosettacode.org/wiki/Bitwise_IO

pad "Expanded (string): " 20 mold to-string expanded

]

 

{{out}}

Expanded (string): "Red forever!"

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

parse arg $; if $=='' then $= 'STRING' /*get optional argument; Use default ? */

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

dcomp: parse arg x; z=; do k=1 by 7 to length(x); _= substr(x, k, 7)

if right(_, 1)==' ' then leave; z= z || x2c( b2x(0 || _) )

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

The implementation accepts the number of bits to discard/expand as an argument.

 

type Output: Iterator<Item = u8>;

 

let decompressed = process_bytes(BitExpand::new(discard), &compressed);

print_bytes(&decompressed);

=={{header|Seed7}}==

several functions to do bitwise I/O. Bitwise data can be read from (or written to) a string or a file.

The direction of bits can be from LSB (least significant bit) to MSB (most significant bit) or vice versa.

In the program below the functions

 

include "bitdata.s7i";

include "strifile.s7i";

const proc: finishWriteAscii (inout file: outFile, inout integer: bitPos) is func

begin

write(outFile, chr(ord(outFile.bufferChar)));

end func;

 

result

var string: stri is "";

var char: ch is ' ';

begin

stri &:= ch;

end if;

var file: aFile is STD_NULL;

var integer: bitPos is 0;

begin

initWriteAscii(aFile, bitPos);

writeAscii(aFile, bitPos, "Hello, Rosetta Code!");

finishWriteAscii(aFile, bitPos);

seek(aFile, 1);

 

{{out}}

 

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

{{trans|Kotlin}}

 

class BitFilter {

for (i in 0...s2.count) bf.read(s2, i, 7, 1)

bf.closeReader()

 

{{out}}

</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}}