/**
* This function creates a binary representation of the huffman tree in order to serialize it to a file.
* The binary representation is created recursively by traversing the tree in an in-order fashion.
* For each non-leaf node encountered a 0 is stored in the binary representation, whereas for the leaf
* nodes an 1 is stored followed by the byte assigned to the node.
*/
static int huffman_tree_serialize_recurse(huffman_node* curr_node, bitset* tree_binary_rep, int *bits_stored) {
int resize_status = check_and_resize_bitset(tree_binary_rep, *bits_stored);
if(resize_status != HUFFMAN_SUCCESS) {
return resize_status;
}
if(curr_node->is_leaf) {
bitset_set_bit(tree_binary_rep, *bits_stored);
(*bits_stored)++;
unsigned char byte = curr_node->which_char;
for(int i = 0; i < 8; i++) {
unsigned char mask = 1 << (8 - i - 1);
int bit = (byte & mask) != 0;
resize_status = check_and_resize_bitset(tree_binary_rep, *bits_stored);
if(resize_status != HUFFMAN_SUCCESS) {
return resize_status;
}
if(bit == 1) {
bitset_set_bit(tree_binary_rep, *bits_stored);
} else {
bitset_clear_bit(tree_binary_rep, *bits_stored);
}
(*bits_stored)++;
}
} else {
bitset_clear_bit(tree_binary_rep, *bits_stored);
(*bits_stored)++;
int left_status = huffman_tree_serialize_recurse(curr_node->left, tree_binary_rep, bits_stored);
if(left_status != HUFFMAN_SUCCESS) {
return left_status;
}
int right_status = huffman_tree_serialize_recurse(curr_node->right, tree_binary_rep, bits_stored);
if(right_status != HUFFMAN_SUCCESS) {
return right_status;
}
}
return HUFFMAN_SUCCESS;
}
int main(int argc, char** argv)
{
int show_details = 0;
printf("\nShow details,run: %s details.\n",argv[0]);
if(argc > 1)
{
if(strcmp("details",argv[1]) == 0)
{
show_details = 1;
}
}
bitset *s = bitset_init(200);
bitset_set_bit(s, 0);
bitset_set_bit(s, 1);
bitset_set_bit(s, 2);
bitset_set_bit(s, 3);
bitset_set_bit(s, 4);
bitset_set_bit(s, 5);
bitset_set_bit(s, 6);
bitset_set_bit(s, 7);
bitset_set_bit(s, 8);
bitset_set_bit(s, 9);
bitset_set_bit(s, 10);
bitset_print(s);
bitset_clear_bit(s, 1);
bitset_clear_bit(s, 4);
bitset_clear_bit(s, 7);
bitset_print(s);
size_t pos = bitset_get_first_unused_bit_pos(s);
printf("pos : %d\n", pos);
bitset_set_bit(s, pos);
pos = bitset_get_first_unused_bit_pos(s);
printf("pos : %d\n", pos);
bitset_free(s);
run(1);
return (EXIT_SUCCESS);
}
/**
* Compute the overhang for a card node
* @param c the leading pair of a node
* @return the bitset of the overhang or NULL (user to free)
*/
bitset *card_node_overhang( card *c )
{
bitset *bs = bitset_create();
bs = bitset_or( bs, pair_versions(c->p) );
if ( pair_is_hint(c->right->p) )
{
pair *pp = c->right->p;
bs = bitset_or( bs, pair_versions(pp) );
if ( pair_is_hint(pp) )
bitset_clear_bit(bs,0);
c = c->right;
}
bitset_and_not( bs, pair_versions(c->right->p) );
return bs;
}
static int fdevent_linux_rtsig_event_del(fdevents * ev, int fde_ndx, int fd)
{
if (fde_ndx < 0)
return -1;
if ((size_t) fde_ndx >= ev->used)
{
fprintf(stderr, "%s.%d: del! out of range %d %zu\n", __FILE__,
__LINE__, fde_ndx, ev->used);
SEGFAULT();
}
if (ev->pollfds[fde_ndx].fd == fd)
{
size_t k = fde_ndx;
ev->pollfds[k].fd = -1;
bitset_clear_bit(ev->sigbset, fd);
if (ev->unused.size == 0)
{
ev->unused.size = 16;
ev->unused.ptr =
malloc(sizeof(*(ev->unused.ptr)) * ev->unused.size);
} else if (ev->unused.size == ev->unused.used)
{
ev->unused.size += 16;
ev->unused.ptr =
realloc(ev->unused.ptr,
sizeof(*(ev->unused.ptr)) * ev->unused.size);
}
ev->unused.ptr[ev->unused.used++] = k;
} else
{
fprintf(stderr, "%s.%d: del! %d %d\n", __FILE__, __LINE__,
ev->pollfds[fde_ndx].fd, fd);
SEGFAULT();
}
return -1;
}
static int
fdevent_freebsd_kqueue_event_add(fdevents * ev, int fde_ndx, int fd, int events)
{
int filter, ret;
struct kevent kev;
struct timespec ts;
UNUSED(fde_ndx);
filter = (events & FDEVENT_IN) ? EVFILT_READ : EVFILT_WRITE;
EV_SET(&kev, fd, filter, EV_ADD | EV_CLEAR, 0, 0, NULL);
ts.tv_sec = 0;
ts.tv_nsec = 0;
ret = kevent(ev->kq_fd, &kev, 1, NULL, 0, &ts);
if (ret == -1)
{
fprintf(stderr, "%s.%d: kqueue failed polling: %s\n",
__FILE__, __LINE__, strerror(errno));
return -1;
}
if (filter == EVFILT_READ)
{
bitset_set_bit(ev->kq_bevents, fd);
} else
{
bitset_clear_bit(ev->kq_bevents, fd);
}
return fd;
}
