Classes
class	BitArray

class	Bits

class	BitStream

class	ByteAlignError

class	ByteStore

class	ConstBitStream

class	ConstByteStore

class	CreationError

class	Error

class	InterpretError

class	MmapByteArray

class	ReadError

Functions
def	offsetcopy (s, newoffset)

def	equal (a, b)

def	tidy_input_string (s)

def	structparser (token)

def	tokenparser (fmt, keys=None, token_cache=None)

def	expand_brackets (s)

def	pack (fmt, values, *kwargs)

Variables
str	__licence__

str	__version__ = "3.1.5"

str	__author__ = "Scott Griffiths"

sys	byteorder = sys.byteorder

bool	bytealigned = False

int	MAX_CHARS = 250

int	CACHE_SIZE = 1000

dict	BYTE_REVERSAL_DICT = dict()

	try :

range	xrange = range

str	basestring = str

len	LEADING_OCT_CHARS = len(oct(1)) - 1

tuple	INIT_NAMES

re	TOKEN_RE

re	DEFAULT_UINT = re.compile(r'(?P<len>[^=]+)?(=(?P<value>.*))?$', re.IGNORECASE)

re	MULTIPLICATIVE_RE = re.compile(r'(?P<factor>.)\(?P<token>.+)')

re	LITERAL_RE = re.compile(r'(?P<name>0(x\|o\|b))(?P<value>.+)', re.IGNORECASE)

re	STRUCT_PACK_RE = re.compile(r'(?P<endian><\|>\|@)?(?P<fmt>(?:\d*[bBhHlLqQfd])+)$')

re	STRUCT_SPLIT_RE = re.compile(r'\d*[bBhHlLqQfd]')

dict	REPLACEMENTS_BE

dict	REPLACEMENTS_LE

dict	PACK_CODE_SIZE

dict	_tokenname_to_initialiser

re	BRACKET_RE = re.compile(r'(?P<factor>\d+)\*\‍(')

list	OCT_TO_BITS = ['{0:03b}'.format(i) for i in xrange(8)]

dict	BIT_COUNT = dict(zip(xrange(256), [bin(i).count('1') for i in xrange(256)]))

dict	name_to_read

dict	init_with_length_and_offset

dict	init_with_length_only

dict	init_without_length_or_offset

Bits	ConstBitArray = Bits

BitStream	BitString = BitStream

list	__all__

Detailed Description

This package defines classes that simplify bit-wise creation, manipulation and
interpretation of data.

Classes:

Bits -- An immutable container for binary data.
BitArray -- A mutable container for binary data.
ConstBitStream -- An immutable container with streaming methods.
BitStream -- A mutable container with streaming methods.

                      Bits (base class)
                     /    \
 + mutating methods /      \ + streaming methods
                   /        \
              BitArray   ConstBitStream
                   \        /
                    \      /
                     \    /
                    BitStream

Functions:

pack -- Create a BitStream from a format string.

Exceptions:

Error -- Module exception base class.
CreationError -- Error during creation.
InterpretError -- Inappropriate interpretation of binary data.
ByteAlignError -- Whole byte position or length needed.
ReadError -- Reading or peeking past the end of a bitstring.

https://github.com/scott-griffiths/bitstring

Function Documentation

◆ equal()

def equal	(	a,
		b
	)

Return True if ByteStores a == b.

Not part of public interface.

Definition at line 292 of file bitstring.py.

def equal(a, b):
    """Return True if ByteStores a == b.
 
    Not part of public interface.
    """
    # We want to return False for inequality as soon as possible, which
    # means we get lots of special cases.
    # First the easy one - compare lengths:
    a_bitlength = a.bitlength
    b_bitlength = b.bitlength
    if a_bitlength != b_bitlength:
        return False
    if not a_bitlength:
        assert b_bitlength == 0
        return True
    # Make 'a' the one with the smaller offset
    if (a.offset % 8) > (b.offset % 8):
        a, b = b, a
    # and create some aliases
    a_bitoff = a.offset % 8
    b_bitoff = b.offset % 8
    a_byteoffset = a.byteoffset
    b_byteoffset = b.byteoffset
    a_bytelength = a.bytelength
    b_bytelength = b.bytelength
    da = a._rawarray
    db = b._rawarray
 
    # If they are pointing to the same data, they must be equal
    if da is db and a.offset == b.offset:
        return True
 
    if a_bitoff == b_bitoff:
        bits_spare_in_last_byte = 8 - (a_bitoff + a_bitlength) % 8
        if bits_spare_in_last_byte == 8:
            bits_spare_in_last_byte = 0
        # Special case for a, b contained in a single byte
        if a_bytelength == 1:
            a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
            b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength)
            return a_val == b_val
        # Otherwise check first byte
        if da[a_byteoffset] & (0xff >> a_bitoff) != db[b_byteoffset] & (0xff >> b_bitoff):
            return False
        # then everything up to the last
        b_a_offset = b_byteoffset - a_byteoffset
        for x in range(1 + a_byteoffset, a_byteoffset + a_bytelength - 1):
            if da[x] != db[b_a_offset + x]:
                return False
        # and finally the last byte
        return (da[a_byteoffset + a_bytelength - 1] >> bits_spare_in_last_byte ==
                db[b_byteoffset + b_bytelength - 1] >> bits_spare_in_last_byte)
 
    assert a_bitoff != b_bitoff
    # This is how much we need to shift a to the right to compare with b:
    shift = b_bitoff - a_bitoff
    # Special case for b only one byte long
    if b_bytelength == 1:
        assert a_bytelength == 1
        a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
        b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength)
        return a_val == b_val
    # Special case for a only one byte long
    if a_bytelength == 1:
        assert b_bytelength == 2
        a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength)
        b_val = ((db[b_byteoffset] << 8) + db[b_byteoffset + 1]) << b_bitoff
        b_val &= 0xffff
        b_val >>= 16 - b_bitlength
        return a_val == b_val
 
    # Compare first byte of b with bits from first byte of a
    if (da[a_byteoffset] & (0xff >> a_bitoff)) >> shift != db[b_byteoffset] & (0xff >> b_bitoff):
        return False
    # Now compare every full byte of b with bits from 2 bytes of a
    for x in range(1, b_bytelength - 1):
        # Construct byte from 2 bytes in a to compare to byte in b
        b_val = db[b_byteoffset + x]
        a_val = ((da[a_byteoffset + x - 1] << 8) + da[a_byteoffset + x]) >> shift
        a_val &= 0xff
        if a_val != b_val:
            return False
 
    # Now check bits in final byte of b
    final_b_bits = (b.offset + b_bitlength) % 8
    if not final_b_bits:
        final_b_bits = 8
    b_val = db[b_byteoffset + b_bytelength - 1] >> (8 - final_b_bits)
    final_a_bits = (a.offset + a_bitlength) % 8
    if not final_a_bits:
        final_a_bits = 8
    if b.bytelength > a_bytelength:
        assert b_bytelength == a_bytelength + 1
        a_val = da[a_byteoffset + a_bytelength - 1] >> (8 - final_a_bits)
        a_val &= 0xff >> (8 - final_b_bits)
        return a_val == b_val
    assert a_bytelength == b_bytelength
    a_val = da[a_byteoffset + a_bytelength - 2] << 8
    a_val += da[a_byteoffset + a_bytelength - 1]
    a_val >>= (8 - final_a_bits)
    a_val &= 0xff >> (8 - final_b_bits)
    return a_val == b_val
 
 

◆ expand_brackets()

def expand_brackets ( s )

Remove whitespace and expand all brackets.

Definition at line 648 of file bitstring.py.

def expand_brackets(s):
    """Remove whitespace and expand all brackets."""
    s = ''.join(s.split())
    while True:
        start = s.find('(')
        if start == -1:
            break
        count = 1  # Number of hanging open brackets
        p = start + 1
        while p < len(s):
            if s[p] == '(':
                count += 1
            if s[p] == ')':
                count -= 1
            if not count:
                break
            p += 1
        if count:
            raise ValueError("Unbalanced parenthesis in '{0}'.".format(s))
        if start == 0 or s[start - 1] != '*':
            s = s[0:start] + s[start + 1:p] + s[p + 1:]
        else:
            m = BRACKET_RE.search(s)
            if m:
                factor = int(m.group('factor'))
                matchstart = m.start('factor')
                s = s[0:matchstart] + (factor - 1) * (s[start + 1:p] + ',') + s[start + 1:p] + s[p + 1:]
            else:
                raise ValueError("Failed to parse '{0}'.".format(s))
    return s
 
 
# This converts a single octal digit to 3 bits.

◆ offsetcopy()

def offsetcopy	(	s,
		newoffset
	)

Return a copy of a ByteStore with the newoffset.

Not part of public interface.

Definition at line 250 of file bitstring.py.

def offsetcopy(s, newoffset):
    """Return a copy of a ByteStore with the newoffset.
 
    Not part of public interface.
    """
    assert 0 <= newoffset < 8
    if not s.bitlength:
        return copy.copy(s)
    else:
        if newoffset == s.offset % 8:
            return ByteStore(s.getbyteslice(s.byteoffset, s.byteoffset + s.bytelength), s.bitlength, newoffset)
        newdata = []
        d = s._rawarray
        assert newoffset != s.offset % 8
        if newoffset < s.offset % 8:
            # We need to shift everything left
            shiftleft = s.offset % 8 - newoffset
            # First deal with everything except for the final byte
            for x in range(s.byteoffset, s.byteoffset + s.bytelength - 1):
                newdata.append(((d[x] << shiftleft) & 0xff) +
                               (d[x + 1] >> (8 - shiftleft)))
            bits_in_last_byte = (s.offset + s.bitlength) % 8
            if not bits_in_last_byte:
                bits_in_last_byte = 8
            if bits_in_last_byte > shiftleft:
                newdata.append((d[s.byteoffset + s.bytelength - 1] << shiftleft) & 0xff)
        else:  # newoffset > s._offset % 8
            shiftright = newoffset - s.offset % 8
            newdata.append(s.getbyte(0) >> shiftright)
            for x in range(s.byteoffset + 1, s.byteoffset + s.bytelength):
                newdata.append(((d[x - 1] << (8 - shiftright)) & 0xff) +
                               (d[x] >> shiftright))
            bits_in_last_byte = (s.offset + s.bitlength) % 8
            if not bits_in_last_byte:
                bits_in_last_byte = 8
            if bits_in_last_byte + shiftright > 8:
                newdata.append((d[s.byteoffset + s.bytelength - 1] << (8 - shiftright)) & 0xff)
        new_s = ByteStore(bytearray(newdata), s.bitlength, newoffset)
        assert new_s.offset == newoffset
        return new_s
 
 

◆ pack()

def pack	(		fmt,
		*	values,
		**	kwargs
	)

Pack the values according to the format string and return a new BitStream.

fmt -- A single string or a list of strings with comma separated tokens
       describing how to create the BitStream.
values -- Zero or more values to pack according to the format.
kwargs -- A dictionary or keyword-value pairs - the keywords used in the
          format string will be replaced with their given value.

Token examples: 'int:12'    : 12 bits as a signed integer
                'uint:8'    : 8 bits as an unsigned integer
                'float:64'  : 8 bytes as a big-endian float
                'intbe:16'  : 2 bytes as a big-endian signed integer
                'uintbe:16' : 2 bytes as a big-endian unsigned integer
                'intle:32'  : 4 bytes as a little-endian signed integer
                'uintle:32' : 4 bytes as a little-endian unsigned integer
                'floatle:64': 8 bytes as a little-endian float
                'intne:24'  : 3 bytes as a native-endian signed integer
                'uintne:24' : 3 bytes as a native-endian unsigned integer
                'floatne:32': 4 bytes as a native-endian float
                'hex:80'    : 80 bits as a hex string
                'oct:9'     : 9 bits as an octal string
                'bin:1'     : single bit binary string
                'ue' / 'uie': next bits as unsigned exp-Golomb code
                'se' / 'sie': next bits as signed exp-Golomb code
                'bits:5'    : 5 bits as a bitstring object
                'bytes:10'  : 10 bytes as a bytes object
                'bool'      : 1 bit as a bool
                'pad:3'     : 3 zero bits as padding

>>> s = pack('uint:12, bits', 100, '0xffe')
>>> t = pack(['bits', 'bin:3'], s, '111')
>>> u = pack('uint:8=a, uint:8=b, uint:55=a', a=6, b=44)

Definition at line 4170 of file bitstring.py.

def pack(fmt, *values, **kwargs):
    """Pack the values according to the format string and return a new BitStream.
 
    fmt -- A single string or a list of strings with comma separated tokens
           describing how to create the BitStream.
    values -- Zero or more values to pack according to the format.
    kwargs -- A dictionary or keyword-value pairs - the keywords used in the
              format string will be replaced with their given value.
 
    Token examples: 'int:12'    : 12 bits as a signed integer
                    'uint:8'    : 8 bits as an unsigned integer
                    'float:64'  : 8 bytes as a big-endian float
                    'intbe:16'  : 2 bytes as a big-endian signed integer
                    'uintbe:16' : 2 bytes as a big-endian unsigned integer
                    'intle:32'  : 4 bytes as a little-endian signed integer
                    'uintle:32' : 4 bytes as a little-endian unsigned integer
                    'floatle:64': 8 bytes as a little-endian float
                    'intne:24'  : 3 bytes as a native-endian signed integer
                    'uintne:24' : 3 bytes as a native-endian unsigned integer
                    'floatne:32': 4 bytes as a native-endian float
                    'hex:80'    : 80 bits as a hex string
                    'oct:9'     : 9 bits as an octal string
                    'bin:1'     : single bit binary string
                    'ue' / 'uie': next bits as unsigned exp-Golomb code
                    'se' / 'sie': next bits as signed exp-Golomb code
                    'bits:5'    : 5 bits as a bitstring object
                    'bytes:10'  : 10 bytes as a bytes object
                    'bool'      : 1 bit as a bool
                    'pad:3'     : 3 zero bits as padding
 
    >>> s = pack('uint:12, bits', 100, '0xffe')
    >>> t = pack(['bits', 'bin:3'], s, '111')
    >>> u = pack('uint:8=a, uint:8=b, uint:55=a', a=6, b=44)
 
    """
    tokens = []
    if isinstance(fmt, basestring):
        fmt = [fmt]
    try:
        for f_item in fmt:
            _, tkns = tokenparser(f_item, tuple(sorted(kwargs.keys())))
            tokens.extend(tkns)
    except ValueError as e:
        raise CreationError(*e.args)
    value_iter = iter(values)
    s = BitStream()
    try:
        for name, length, value in tokens:
            # If the value is in the kwd dictionary then it takes precedence.
            if value in kwargs:
                value = kwargs[value]
            # If the length is in the kwd dictionary then use that too.
            if length in kwargs:
                length = kwargs[length]
            # Also if we just have a dictionary name then we want to use it
            if name in kwargs and length is None and value is None:
                s.append(kwargs[name])
                continue
            if length is not None:
                length = int(length)
            if value is None and name != 'pad':
                # Take the next value from the ones provided
                value = next(value_iter)
            s._append(BitStream._init_with_token(name, length, value))
    except StopIteration:
        raise CreationError("Not enough parameters present to pack according to the "
                            "format. {0} values are needed.", len(tokens))
    try:
        next(value_iter)
    except StopIteration:
        # Good, we've used up all the *values.
        return s
    raise CreationError("Too many parameters present to pack according to the format.")
 
 
# Aliases for backward compatibility

◆ structparser()

def structparser ( token )

Parse struct-like format string token into sub-token list.

Definition at line 511 of file bitstring.py.

def structparser(token):
    """Parse struct-like format string token into sub-token list."""
    m = STRUCT_PACK_RE.match(token)
    if not m:
        return [token]
    else:
        endian = m.group('endian')
        if endian is None:
            return [token]
        # Split the format string into a list of 'q', '4h' etc.
        formatlist = re.findall(STRUCT_SPLIT_RE, m.group('fmt'))
        # Now deal with mulitiplicative factors, 4h -> hhhh etc.
        fmt = ''.join([f[-1] * int(f[:-1]) if len(f) != 1 else
                       f for f in formatlist])
        if endian == '@':
            # Native endianness
            if byteorder == 'little':
                endian = '<'
            else:
                assert byteorder == 'big'
                endian = '>'
        if endian == '<':
            tokens = [REPLACEMENTS_LE[c] for c in fmt]
        else:
            assert endian == '>'
            tokens = [REPLACEMENTS_BE[c] for c in fmt]
    return tokens
 
 

◆ tidy_input_string()

def tidy_input_string ( s )

Return string made lowercase and with all whitespace removed.

Definition at line 463 of file bitstring.py.

def tidy_input_string(s):
    """Return string made lowercase and with all whitespace removed."""
    s = ''.join(s.split()).lower()
    return s
 
 

◆ tokenparser()

def tokenparser	(	fmt,
		keys = `None`,
		token_cache = `None`
	)

Divide the format string into tokens and parse them.

Return stretchy token and list of [initialiser, length, value]
initialiser is one of: hex, oct, bin, uint, int, se, ue, 0x, 0o, 0b etc.
length is None if not known, as is value.

If the token is in the keyword dictionary (keys) then it counts as a
special case and isn't messed with.

tokens must be of the form: [factor*][initialiser][:][length][=value]

Definition at line 540 of file bitstring.py.

def tokenparser(fmt, keys=None, token_cache=None):
    """Divide the format string into tokens and parse them.
 
    Return stretchy token and list of [initialiser, length, value]
    initialiser is one of: hex, oct, bin, uint, int, se, ue, 0x, 0o, 0b etc.
    length is None if not known, as is value.
 
    If the token is in the keyword dictionary (keys) then it counts as a
    special case and isn't messed with.
 
    tokens must be of the form: [factor*][initialiser][:][length][=value]
 
    """
    if token_cache is None:
        token_cache = {}
    try:
        return token_cache[(fmt, keys)]
    except KeyError:
        token_key = (fmt, keys)
    # Very inefficient expanding of brackets.
    fmt = expand_brackets(fmt)
    # Split tokens by ',' and remove whitespace
    # The meta_tokens can either be ordinary single tokens or multiple
    # struct-format token strings.
    meta_tokens = (''.join(f.split()) for f in fmt.split(','))
    return_values = []
    stretchy_token = False
    for meta_token in meta_tokens:
        # See if it has a multiplicative factor
        m = MULTIPLICATIVE_RE.match(meta_token)
        if not m:
            factor = 1
        else:
            factor = int(m.group('factor'))
            meta_token = m.group('token')
        # See if it's a struct-like format
        tokens = structparser(meta_token)
        ret_vals = []
        for token in tokens:
            if keys and token in keys:
                # Don't bother parsing it, it's a keyword argument
                ret_vals.append([token, None, None])
                continue
            value = length = None
            if token == '':
                continue
            # Match literal tokens of the form 0x... 0o... and 0b...
            m = LITERAL_RE.match(token)
            if m:
                name = m.group('name')
                value = m.group('value')
                ret_vals.append([name, length, value])
                continue
            # Match everything else:
            m1 = TOKEN_RE.match(token)
            if not m1:
                # and if you don't specify a 'name' then the default is 'uint':
                m2 = DEFAULT_UINT.match(token)
                if not m2:
                    raise ValueError("Don't understand token '{0}'.".format(token))
            if m1:
                name = m1.group('name')
                length = m1.group('len')
                if m1.group('value'):
                    value = m1.group('value')
            else:
                assert m2
                name = 'uint'
                length = m2.group('len')
                if m2.group('value'):
                    value = m2.group('value')
            if name == 'bool':
                if length is not None:
                    raise ValueError("You can't specify a length with bool tokens - they are always one bit.")
                length = 1
            if length is None and name not in ('se', 'ue', 'sie', 'uie'):
                stretchy_token = True
            if length is not None:
                # Try converting length to int, otherwise check it's a key.
                try:
                    length = int(length)
                    if length < 0:
                        raise Error
                    # For the 'bytes' token convert length to bits.
                    if name == 'bytes':
                        length *= 8
                except Error:
                    raise ValueError("Can't read a token with a negative length.")
                except ValueError:
                    if not keys or length not in keys:
                        raise ValueError("Don't understand length '{0}' of token.".format(length))
            ret_vals.append([name, length, value])
        # This multiplies by the multiplicative factor, but this means that
        # we can't allow keyword values as multipliers (e.g. n*uint:8).
        # The only way to do this would be to return the factor in some fashion
        # (we can't use the key's value here as it would mean that we couldn't
        # sensibly continue to cache the function's results. (TODO).
        return_values.extend(ret_vals * factor)
    return_values = [tuple(x) for x in return_values]
    if len(token_cache) < CACHE_SIZE:
        token_cache[token_key] = stretchy_token, return_values
    return stretchy_token, return_values
 
 
# Looks for first number*(

Variable Documentation

◆ all

list __all__

private

Initial value:

=  ['ConstBitArray', 'ConstBitStream', 'BitStream', 'BitArray',
           'Bits', 'BitString', 'pack', 'Error', 'ReadError',
           'InterpretError', 'ByteAlignError', 'CreationError', 'bytealigned']

Definition at line 4249 of file bitstring.py.

◆ author

str __author__ = "Scott Griffiths"

private

Definition at line 65 of file bitstring.py.

◆ licence

str __licence__

private

Initial value:

=  """
The MIT License
 
Copyright (c) 2006-2016 Scott Griffiths (dr.scottgriffiths@gmail.com)
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""

Definition at line 39 of file bitstring.py.

◆ version

str __version__ = "3.1.5"

private

Definition at line 63 of file bitstring.py.

◆ _tokenname_to_initialiser

dict _tokenname_to_initialiser

protected

Initial value:

=  {'hex': 'hex', '0x': 'hex', '0X': 'hex', 'oct': 'oct',
                             '0o': 'oct', '0O': 'oct', 'bin': 'bin', '0b': 'bin',
                             '0B': 'bin', 'bits': 'auto', 'bytes': 'bytes', 'pad': 'pad'}

Definition at line 506 of file bitstring.py.

◆ basestring

str basestring = str

Definition at line 457 of file bitstring.py.

◆ BIT_COUNT

dict BIT_COUNT = dict(zip(xrange(256), [bin(i).count('1') for i in xrange(256)]))

Definition at line 684 of file bitstring.py.

◆ BitString

BitStream BitString = BitStream

Definition at line 4247 of file bitstring.py.

◆ BRACKET_RE

re BRACKET_RE = re.compile(r'(?P<factor>\d+)\*\‍(')

Definition at line 645 of file bitstring.py.

◆ BYTE_REVERSAL_DICT

dict BYTE_REVERSAL_DICT = dict()

Definition at line 444 of file bitstring.py.

◆ bytealigned

bool bytealigned = False

Definition at line 81 of file bitstring.py.

◆ byteorder

sys byteorder = sys.byteorder

Definition at line 79 of file bitstring.py.

◆ CACHE_SIZE

int CACHE_SIZE = 1000

Definition at line 88 of file bitstring.py.

◆ ConstBitArray

Bits ConstBitArray = Bits

Definition at line 4246 of file bitstring.py.

◆ DEFAULT_UINT

re DEFAULT_UINT = re.compile(r'(?P<len>[^=]+)?(=(?P<value>.*))?$', re.IGNORECASE)

Definition at line 475 of file bitstring.py.

◆ INIT_NAMES

tuple INIT_NAMES

Initial value:

=  ('uint', 'int', 'ue', 'se', 'sie', 'uie', 'hex', 'oct', 'bin', 'bits',
              'uintbe', 'intbe', 'uintle', 'intle', 'uintne', 'intne',
              'float', 'floatbe', 'floatle', 'floatne', 'bytes', 'bool', 'pad')

Definition at line 469 of file bitstring.py.

◆ init_with_length_and_offset

dict init_with_length_and_offset

Initial value:

=  {'bytes': Bits._setbytes_safe,
                               'filename': Bits._setfile,
                               }

Definition at line 2920 of file bitstring.py.

◆ init_with_length_only

dict init_with_length_only

Initial value:

=  {'uint': Bits._setuint,
                         'int': Bits._setint,
                         'float': Bits._setfloat,
                         'uintbe': Bits._setuintbe,
                         'intbe': Bits._setintbe,
                         'floatbe': Bits._setfloat,
                         'uintle': Bits._setuintle,
                         'intle': Bits._setintle,
                         'floatle': Bits._setfloatle,
                         'uintne': Bits._setuintne,
                         'intne': Bits._setintne,
                         'floatne': Bits._setfloatne,
                         }

Definition at line 2924 of file bitstring.py.

◆ init_without_length_or_offset

dict init_without_length_or_offset

Initial value:

=  {'bin': Bits._setbin_safe,
                                 'hex': Bits._sethex,
                                 'oct': Bits._setoct,
                                 'ue': Bits._setue,
                                 'se': Bits._setse,
                                 'uie': Bits._setuie,
                                 'sie': Bits._setsie,
                                 'bool': Bits._setbool,
                                 }

Definition at line 2938 of file bitstring.py.

◆ LEADING_OCT_CHARS

len LEADING_OCT_CHARS = len(oct(1)) - 1

Definition at line 460 of file bitstring.py.

◆ LITERAL_RE

re LITERAL_RE = re.compile(r'(?P<name>0(x|o|b))(?P<value>.+)', re.IGNORECASE)

Definition at line 480 of file bitstring.py.

◆ MAX_CHARS

int MAX_CHARS = 250

Definition at line 85 of file bitstring.py.

◆ MULTIPLICATIVE_RE

re MULTIPLICATIVE_RE = re.compile(r'(?P<factor>.*)\*(?P<token>.+)')

Definition at line 477 of file bitstring.py.

◆ name_to_read

dict name_to_read

Initial value:

=  {'uint': Bits._readuint,
                'uintle': Bits._readuintle,
                'uintbe': Bits._readuintbe,
                'uintne': Bits._readuintne,
                'int': Bits._readint,
                'intle': Bits._readintle,
                'intbe': Bits._readintbe,
                'intne': Bits._readintne,
                'float': Bits._readfloat,
                'floatbe': Bits._readfloat,  # floatbe is a synonym for float
                'floatle': Bits._readfloatle,
                'floatne': Bits._readfloatne,
                'hex': Bits._readhex,
                'oct': Bits._readoct,
                'bin': Bits._readbin,
                'bits': Bits._readbits,
                'bytes': Bits._readbytes,
                'ue': Bits._readue,
                'se': Bits._readse,
                'uie': Bits._readuie,
                'sie': Bits._readsie,
                'bool': Bits._readbool,
                }

Definition at line 2895 of file bitstring.py.

◆ OCT_TO_BITS

list OCT_TO_BITS = ['{0:03b}'.format(i) for i in xrange(8)]

Definition at line 681 of file bitstring.py.

◆ PACK_CODE_SIZE

dict PACK_CODE_SIZE

Initial value:

1= {'b': 1, 'B': 1, 'h': 2, 'H': 2, 'l': 4, 'L': 4,

2 'q': 8, 'Q': 8, 'f': 4, 'd': 8}

Definition at line 503 of file bitstring.py.

◆ REPLACEMENTS_BE

dict REPLACEMENTS_BE

Initial value:

=  {'b': 'intbe:8', 'B': 'uintbe:8',
                   'h': 'intbe:16', 'H': 'uintbe:16',
                   'l': 'intbe:32', 'L': 'uintbe:32',
                   'q': 'intbe:64', 'Q': 'uintbe:64',
                   'f': 'floatbe:32', 'd': 'floatbe:64'}

Definition at line 490 of file bitstring.py.

◆ REPLACEMENTS_LE

dict REPLACEMENTS_LE

Initial value:

=  {'b': 'intle:8', 'B': 'uintle:8',
                   'h': 'intle:16', 'H': 'uintle:16',
                   'l': 'intle:32', 'L': 'uintle:32',
                   'q': 'intle:64', 'Q': 'uintle:64',
                   'f': 'floatle:32', 'd': 'floatle:64'}

Definition at line 496 of file bitstring.py.

◆ STRUCT_PACK_RE

re STRUCT_PACK_RE = re.compile(r'(?P<endian><|>|@)?(?P<fmt>(?:\d*[bBhHlLqQfd])+)$')

Definition at line 483 of file bitstring.py.

◆ STRUCT_SPLIT_RE

re STRUCT_SPLIT_RE = re.compile(r'\d*[bBhHlLqQfd]')

Definition at line 486 of file bitstring.py.

◆ TOKEN_RE

re TOKEN_RE

Initial value:

1= re.compile(r'(?P<name>' + '|'.join(INIT_NAMES) +

2 r')((:(?P<len>[^=]+)))?(=(?P<value>.*))?$', re.IGNORECASE)

Definition at line 473 of file bitstring.py.

◆ try

try :

Definition at line 448 of file bitstring.py.

◆ xrange

range xrange = range

Definition at line 456 of file bitstring.py.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ equal()

◆ expand_brackets()

◆ offsetcopy()

◆ pack()

◆ structparser()

◆ tidy_input_string()

◆ tokenparser()

Variable Documentation

◆ __all__

◆ __author__

◆ __licence__

◆ __version__

◆ _tokenname_to_initialiser

◆ basestring

◆ BIT_COUNT

◆ BitString

◆ BRACKET_RE

◆ BYTE_REVERSAL_DICT

◆ bytealigned

◆ byteorder

◆ CACHE_SIZE

◆ ConstBitArray

◆ DEFAULT_UINT

◆ INIT_NAMES

◆ init_with_length_and_offset

◆ init_with_length_only

◆ init_without_length_or_offset

◆ LEADING_OCT_CHARS

◆ LITERAL_RE

◆ MAX_CHARS

◆ MULTIPLICATIVE_RE

◆ name_to_read

◆ OCT_TO_BITS

◆ PACK_CODE_SIZE

◆ REPLACEMENTS_BE

◆ REPLACEMENTS_LE

◆ STRUCT_PACK_RE

◆ STRUCT_SPLIT_RE

◆ TOKEN_RE

◆ try

◆ xrange

◆ all

◆ author

◆ licence

◆ version