cBytes

Overview

It is recommended to use cBytes and cVarBytes for data buffer.

Types and Definitions

Generated

cBytes

struct cBytes
{
   int64_t s;
   cByte const* v;
};
typedef struct cBytes cBytes;

Via the macros SLICE_DEF_C_ and SLICE_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

/* init */
cBytes bytes_c( int64_t s, cByte const* v );
cBytes make_bytes_c( cByte const* beg, cByte const* end );
cBytes empty_bytes_c( void );
/* sub */
cBytes left_bytes_c( cBytes bytes, int64_t maxLen );
cBytes mid_bytes_c( cBytes bytes, int64_t index );
cBytes right_bytes_c( cBytes bytes, int64_t maxLen );
cBytes sub_bytes_c( cBytes bytes, int64_t begIdx,  int64_t endIdx );

cVarBytes

struct cVarBytes
{
   int64_t s;
   cByte* v;
};
typedef struct cVarBytes cVarBytes;

Via the macros SLICE_DEF_C_ and SLICE_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

/* init */
cVarBytes var_bytes_c( int64_t s, cByte* v );
cVarBytes make_var_bytes_c( cByte* beg, cByte* end );
cVarBytes empty_var_bytes_c( void );
/* sub */
cVarBytes left_var_bytes_c( cVarBytes bytes, int64_t maxLen );
cVarBytes mid_var_bytes_c( cVarBytes bytes, int64_t index );
cVarBytes right_var_bytes_c( cVarBytes bytes, int64_t maxLen );
cVarBytes sub_var_bytes_c( cVarBytes bytes, int64_t begIdx, int64_t endIdx );
/* var slice */
cBytes as_bytes_c( cVarBytes bytes );
cVarBytes cast_bytes_c( cVarBytes bytes, cBytes sub );
int64_t set_bytes_c( cVarBytes dst, cBytes src );

cByteChunk

struct cByteChunk
{
   int64_t s;
   cByte const* v;
   int64_t favSize;
   cBytes slice;
};
typedef struct cByteChunk cByteChunk;

Via the macros CHUNK_DEF_C_ and CHUNK_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

void init_back_byte_chunk_c( cByteChunk chunk[static 1],
                             int64_t s,
                             cBytes slice );
void init_front_byte_chunk_c( cByteChunk chunk[static 1],
                              int64_t s,
                              cBytes slice );

cVarByteChunk

struct cVarByteChunk
{
   int64_t s;
   cByte* v;
   int64_t favSize;
   cVarBytes slice;
};
typedef struct cVarByteChunk cVarByteChunk;

Via the macros CHUNK_DEF_C_ and CHUNK_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

void init_back_var_byte_chunk_c( cVarByteChunk chunk[static 1],
                                 int64_t s,
                                 cVarBytes slice );
void init_front_var_byte_chunk_c( cVarByteChunk chunk[static 1],
                                  int64_t s,
                                  cVarBytes slice );

cByteWindow

struct cByteWindow
{
   int64_t s;
   cByte const* v;
   cBytes slice;
};
typedef struct cByteWindow cByteWindow;

Via the macros WINDOW_DEF_C_ and WINDOW_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

void init_back_byte_window_c( cByteWindow window[static 1],
                              int64_t s,
                              cBytes slice );
void init_front_byte_window_c( cByteWindow window[static 1],
                               int64_t s,
                               cBytes slice );

cVarByteWindow

struct cVarByteWindow
{
   int64_t s;
   cByte* v;
   cVarBytes slice;
};
typedef struct cVarByteWindow cVarByteWindow;

Via the macros WINDOW_DEF_C_ and WINDOW_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

void init_back_var_byte_window_c( cVarByteWindow window[static 1],
                                  int64_t s,
                                  cVarBytes slice );
void init_front_var_byte_window_c( cVarByteWindow window[static 1],
                                   int64_t s,
                                   cVarBytes slice );

Functions

overall

byte_buffer_c_

#define byte_buffer_c_( Size )

Macro function that initalizes a cVarBytes that can store Size values.

bit

get_bytes_bit_c

cByte get_bytes_bit_c( cBytes slice, int64_t pos );

Returns the bit at pos in the byte slice.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cBytes slice = slice_c_( cByte, 0xa2, 0xdb );

   // a - 1010
   expect_c_( get_bytes_bit_c( slice,  0 ) == 1 );
   expect_c_( get_bytes_bit_c( slice,  1 ) == 0 );
   expect_c_( get_bytes_bit_c( slice,  2 ) == 1 );
   expect_c_( get_bytes_bit_c( slice,  3 ) == 0 );
   // 2 - 0010
   expect_c_( get_bytes_bit_c( slice,  4 ) == 0 );
   expect_c_( get_bytes_bit_c( slice,  5 ) == 0 );
   expect_c_( get_bytes_bit_c( slice,  6 ) == 1 );
   expect_c_( get_bytes_bit_c( slice,  7 ) == 0 );
   // d - 1101
   expect_c_( get_bytes_bit_c( slice,  8 ) == 1 );
   expect_c_( get_bytes_bit_c( slice,  9 ) == 1 );
   expect_c_( get_bytes_bit_c( slice, 10 ) == 0 );
   expect_c_( get_bytes_bit_c( slice, 11 ) == 1 );
   // b - 1011
   expect_c_( get_bytes_bit_c( slice, 12 ) == 1 );
   expect_c_( get_bytes_bit_c( slice, 13 ) == 0 );
   expect_c_( get_bytes_bit_c( slice, 14 ) == 1 );
   expect_c_( get_bytes_bit_c( slice, 15 ) == 1 );

   return finish_tap_c_();
}

set_bytes_bit_c

void set_bytes_bit_c( cVarBytes slice, int64_t pos, cByte bit );

Sets the bit at pos in the byte slice.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cVarBytes slice = slice_c_( cByte, 0x00, 0xff );

   set_bytes_bit_c( slice, 0, 1 );
   set_bytes_bit_c( slice, 2, 1 );
   set_bytes_bit_c( slice, 6, 1 );

   set_bytes_bit_c( slice, 10, 0 );
   set_bytes_bit_c( slice, 13, 0 );

   expect_c_( slice.v[0] == 0xa2 ); // 0-7   -> 1010 0010
   expect_c_( slice.v[1] == 0xdb ); // 8-15  -> 1101 1011

   return finish_tap_c_();
}

set_bytes_bits_c

void set_bytes_bits_c( cVarBytes slice, cRange range, cByte bit );

Sets all bits inside the range with the bit value.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cVarBytes slice = slice_c_( cByte, 0x0f, 0xf0 );

   set_bytes_bits_c( slice, closed_range_c_( 5, 9 ), 0 );
   expect_c_( slice.v[0] == 0x08 ); // 0-7    -> 0000 1000
   expect_c_( slice.v[1] == 0x30 ); // 8-15   -> 0011 0000

   set_bytes_bits_c( slice, closed_range_c_( 2, 5 ), 1 );
   expect_c_( slice.v[0] == 0x3c ); // 0-7    -> 0011 1100
   expect_c_( slice.v[1] == 0x30 ); // 8-15   -> 0011 0000

   return finish_tap_c_();
}

set_odd_byte_c

void set_odd_byte_c( cVarBytes slice, int64_t pos, int64_t bitOffset, cByte byte );

Sets a byte value that overlaps with two bytes in the byte slice.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

#define expect_bytes_( Slice, ... )                                            \
   expect_eq_c_(                                                               \
      cmp_bytes_c(                                                             \
         as_bytes_c( Slice ),                                                  \
         bytes_c( (Slice).s, (cByte[]){ __VA_ARGS__ } )                        \
      )                                                                        \
   )

int main( void )
{
   init_tap_c_();

   // 11110001 11110011 11110101 11110111 11110000
   cVarBytes bytes = slice_c_( cByte, 0xf1, 0xf3, 0xf5, 0xf7, 0xf0 );

   set_odd_byte_c( bytes, 2, 4, 0x44 ); // 01000100
   // 11110001 11110011 11110100 01000111 11110000
   expect_bytes_( bytes, 0xf1, 0xf3, 0xf4, 0x47, 0xf0 );

   set_odd_byte_c( bytes, 0, 0, 0x12 ); // 00010010
   // 00010010 11110011 11110100 01000111 11110000
   expect_bytes_( bytes, 0x12, 0xf3, 0xf4, 0x47, 0xf0 );

   set_odd_byte_c( bytes, 4, 7, 0xff ); // 11111111
   // 00010010 11110011 11110100 01000111 11110001
   expect_bytes_( bytes, 0x12, 0xf3, 0xf4, 0x47, 0xf1 );

   return finish_tap_c_();
}

shift_bytes_c

void shift_bytes_c( cVarBytes slice, int64_t offset, cByte fillValue );

Shifts the bits in a byte slice. A negative offset shifts the bits to the left, a positive offset shifts the bits to the right.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

#define expect_bytes_( Slice, ... )                                            \
   expect_eq_c_(                                                               \
      cmp_bytes_c(                                                             \
         as_bytes_c( Slice ),                                                  \
         bytes_c( (Slice).s, (cByte[]){ __VA_ARGS__ } )                        \
      )                                                                        \
   )

int main( void )
{
   init_tap_c_();

   // ----------------------------------------------------- left shift
   {
      // 00001111 00001111 00001111 00001111 00001111
      cVarBytes bytes = slice_c_( cByte, 0x0f, 0x0f, 0x0f, 0x0f, 0xf );
      shift_bytes_c( bytes, -5, 0 );
      // 11100001 11100001 11100001 11100001 11100000
      expect_bytes_( bytes, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0 );
   }
   {
      // 00000011 10000111 10000111 10000111 10000111
      cVarBytes bytes = slice_c_( cByte, 0x03, 0x87, 0x87, 0x87, 0x87 );
      shift_bytes_c( bytes, -13, 0 );
      // 11110000 11110000 11110000 11100000 00000000
      expect_bytes_( bytes, 0xf0, 0xf0, 0xf0, 0xe0, 0x00 );
   }

   {
      // 00000000 00000000 00000000 00000000 00000001
      cVarBytes bytes = slice_c_( cByte, 0x00, 0x00, 0x00, 0x00, 0x01 );
      shift_bytes_c( bytes, -39, 1 );
      // 11111111 11111111 11111111 11111111 11111111
      expect_bytes_( bytes, 0xff, 0xff, 0xff, 0xff, 0xff );
   }

   // ----------------------------------------------------- right shift
   {
      // 11100001 11100001 11100001 11100001 11100000
      cVarBytes bytes = slice_c_( cByte, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0 );
      shift_bytes_c( bytes, 6, 0 );
      // 00000011 10000111 10000111 10000111 10000111
      expect_bytes_( bytes, 0x03, 0x87, 0x87, 0x87, 0x87 );
   }
   {
      // 11110000 11110000 11110000 11100000 00000000
      cVarBytes bytes = slice_c_( cByte, 0xf0, 0xf0, 0xf0, 0xe0, 0x00 );
      shift_bytes_c( bytes, 16, 0 );
      // 00000000 00000000 11110000 11110000 11110000
      expect_bytes_( bytes, 0x00, 0x00, 0xf0, 0xf0, 0xf0 );
   }
   {
      // 10000000 00000000 00000000 00000000 00000000
      cVarBytes bytes = slice_c_( cByte, 0x80, 0x00, 0x00, 0x00, 0x00 );
      shift_bytes_c( bytes, 39, 1 );
      // 11111111 11111111 11111111 11111111 11111111
      expect_bytes_( bytes, 0xff, 0xff, 0xff, 0xff, 0xff );
   }

   // ----------------------------------------------------- left & right shift
   {
      // 00001111 00001111 00001111 00001111 00001111
      cVarBytes bytes = slice_c_( cByte, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f );

      shift_bytes_c( bytes, -5, 0 );
      // 11100001 11100001 11100001 11100001 11100000
      expect_bytes_( bytes, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0 );

      shift_bytes_c( bytes, 6, 0 );
      // 00000011 10000111 10000111 10000111 10000111
      expect_bytes_( bytes, 0x03, 0x87, 0x87, 0x87, 0x87 );

      shift_bytes_c( bytes, -13, 0 );
      // 11110000 11110000 11110000 11100000 00000000
      expect_bytes_( bytes, 0xf0, 0xf0, 0xf0, 0xe0, 0x00 );

      shift_bytes_c( bytes, 16, 0 );
      // 00000000 00000000 11110000 11110000 11110000
      expect_bytes_( bytes, 0x00, 0x00, 0xf0, 0xf0, 0xf0 );
   }

   return finish_tap_c_();
}

toggle_bytes_bit_c

void toggle_bytes_bit_c( cVarBytes slice, int64_t pos );

Toggles the bit at pos in the byte slice.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cVarBytes slice = slice_c_( cByte, 0x00, 0xff );

   toggle_bytes_bit_c( slice, 0 );
   toggle_bytes_bit_c( slice, 2 );
   toggle_bytes_bit_c( slice, 6 );

   toggle_bytes_bit_c( slice, 10 );
   toggle_bytes_bit_c( slice, 13 );

   expect_c_( slice.v[ 0 ] == 0xa2 ); // 0-7   -> 1010 0010
   expect_c_( slice.v[ 1 ] == 0xdb ); // 8-15  -> 1101 1011

   return finish_tap_c_();
}

logic

bitand_bytes_c

bool bitand_bytes_c( cBytes a, cBytes b, cVarBytes result );

Combines the bits of a and b with a logical and. Returns false if the slices have different s values.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cBytes a = slice_c_( cByte, 0x0f, 0xc3, 0x5d, 0x10 );
   cBytes b = slice_c_( cByte, 0x10, 0x5d, 0x0f, 0xc3 );
   cVarBytes result = scalars_c_( 4, cByte );

   bitand_bytes_c( a, b, result );

   expect_c_( result.v[ 0 ] == 0x00 );
   expect_c_( result.v[ 1 ] == 0x41 );
   expect_c_( result.v[ 2 ] == 0x0d );
   expect_c_( result.v[ 3 ] == 0x00 );

   return finish_tap_c_();
}

bitor_bytes_c

bool bitor_bytes_c( cBytes a, cBytes b, cVarBytes result );

Combines the bits of a and b with a logical or. Returns false if the slices have different s values.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cBytes a = slice_c_( cByte, 0x0f, 0xc3, 0x5d, 0x10 );
   cBytes b = slice_c_( cByte, 0x10, 0x5d, 0x0f, 0xc3 );
   cVarBytes result = scalars_c_( 4, cByte );

   bitor_bytes_c( a, b, result );

   expect_c_( result.v[ 0 ] == 0x1f );
   expect_c_( result.v[ 1 ] == 0xdf );
   expect_c_( result.v[ 2 ] == 0x5f );
   expect_c_( result.v[ 3 ] == 0xd3 );

   return finish_tap_c_();
}

compl_bytes_c

bool compl_bytes_c( cBytes a, cVarBytes result );

Builds the complement of the slice a. Returns false if the slices have different s values.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cVarBytes slice = slice_c_( cByte, 0x0f, 0xc3, 0x5d, 0x10 );

   compl_bytes_c( as_bytes_c( slice ), slice );

   expect_c_( slice.v[ 0 ] == 0xf0 );
   expect_c_( slice.v[ 1 ] == 0x3c );
   expect_c_( slice.v[ 2 ] == 0xa2 );
   expect_c_( slice.v[ 3 ] == 0xef );

   return finish_tap_c_();
}

xor_bytes_c

bool xor_bytes_c( cBytes a, cBytes b, cVarBytes result );

Combine the bits of a and b with a logical xor. Returns false if the slices have different s values.

Example
#include "clingo/lang/expect.h"
#include "clingo/type/cBytes.h"

int main( void )
{
   init_tap_c_();

   cBytes a = slice_c_( cByte, 0x0f, 0xc3, 0x5d, 0x10 );
   cBytes b = slice_c_( cByte, 0x10, 0x5d, 0x0f, 0xc3 );
   cVarBytes result = scalars_c_( 4, cByte );

   xor_bytes_c( a, b, result );

   expect_c_( result.v[ 0 ] == 0x1f );
   expect_c_( result.v[ 1 ] == 0x9e );
   expect_c_( result.v[ 2 ] == 0x52 );
   expect_c_( result.v[ 3 ] == 0xd3 );

   return finish_tap_c_();
}

algo

bytes_ends_with_c

bool bytes_ends_with_c( cBytes slice, cBytes needle );

Via the macro ENDS_WITH_C_ implemented function.

bytes_starts_with_c

bool bytes_starts_with_c( cBytes slice, cBytes needle );

Via the macro STARTS_WITH_C_ implemented function.

cmp_bytes_c

#define cmp_bytes_c_( Slice, ... )                                             \
   cmp_bytes_c( (Slice), ((cBytes)slice_c_( cByte, __VA_ARGS__ )) )
int cmp_bytes_c( cBytes a, cBytes b );

Via the macro CMP_SLICE_C_ implemented function.

count_eq_byte_c

int64_t count_eq_byte_c( cBytes slice, cByte val );

Via the macro COUNT_EQ_C_ implemented function.

find_byte_c

cByte const* find_byte_c( cBytes slice, cByte val );

Via the macro FIND_VAL_C_ implemented function.

index_of_bytes_c

int64_t index_of_bytes_c( cBytes slice, cBytes sub );

Via the macro INDEX_OF_SLICE_C_ implemented function.

insert_byte_c

int64_t insert_byte_c( cVarBytes slice, int64_t index, cByte val );

Via the macro INSERT_VAL_C_ implemented function.

insert_bytes_c

int64_t insert_bytes_c( cVarBytes dst, int64_t index, cBytes src );

Via the macro INSERT_SLICE_C_ implemented function.