113 lines
2.6 KiB
C
113 lines
2.6 KiB
C
#include "type_boolarray.h"
|
|
|
|
barray *create_barray(uint size) {
|
|
barray *ptr = malloc(sizeof(barray));
|
|
ptr->size = size;
|
|
if (size % 8 == 0) {
|
|
ptr->size_array = size / 8;
|
|
} else {
|
|
ptr->size_array = size / 8 + 1;
|
|
}
|
|
ptr->array = malloc(ptr->size_array * sizeof(uchar));
|
|
for (uint i = 0; i < ptr->size_array; i++) {
|
|
ptr->array[i] = false;
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
uint getsize_barray(barray *ptr) {
|
|
if (ptr == NULL) {
|
|
ERROR("getsize_barray: ptr is NULL");
|
|
}
|
|
return ptr->size;
|
|
}
|
|
|
|
void delete_barray(barray *ptr) {
|
|
if (ptr == NULL) {
|
|
return;
|
|
}
|
|
if (ptr->array != NULL) {
|
|
free(ptr->array);
|
|
}
|
|
free(ptr);
|
|
return;
|
|
}
|
|
|
|
void settrue_barray(barray *ptr, uint num_bool) {
|
|
if (ptr == NULL) {
|
|
ERROR("settrue_barray: ptr is NULL");
|
|
}
|
|
if (num_bool >= ptr->size) {
|
|
ERROR("settrue_barray: cell is out of bounds");
|
|
}
|
|
uint cell = num_bool / 8;
|
|
uint bit = num_bool % 8;
|
|
ptr->array[cell] |= 1 << bit;
|
|
return;
|
|
}
|
|
|
|
void setfalse_barray(barray *ptr, uint num_bool) {
|
|
if (ptr == NULL) {
|
|
ERROR("setfalse_barray: ptr is NULL");
|
|
}
|
|
if (num_bool >= ptr->size) {
|
|
ERROR("setfalse_barray: cell is out of bounds");
|
|
}
|
|
uint cell = num_bool / 8;
|
|
uint bit = num_bool % 8;
|
|
ptr->array[cell] &= ~(1 << bit);
|
|
return;
|
|
}
|
|
|
|
bool getval_barray(barray *ptr, uint num_bool) {
|
|
if (ptr == NULL) {
|
|
ERROR("getval_barray: ptr is NULL");
|
|
}
|
|
if (num_bool >= ptr->size) {
|
|
ERROR("getval_barray: cell is out of bounds");
|
|
}
|
|
uint cell = num_bool / 8;
|
|
uint bit = num_bool % 8;
|
|
return (ptr->array[cell] & 1 << bit);
|
|
}
|
|
|
|
barray *or_barray(barray *ptr1, barray *ptr2) {
|
|
if (ptr1 == NULL || ptr2 == NULL) {
|
|
ERROR("or_barray: ptr is NULL");
|
|
}
|
|
if (ptr1->size != ptr2->size) {
|
|
return NULL;
|
|
}
|
|
barray *ptr = create_barray(ptr1->size);
|
|
for (uint i = 0; i < ptr->size; i++) {
|
|
ptr->array[i] = ptr1->array[i] | ptr2->array[i];
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
barray *and_barray(barray *ptr1, barray *ptr2) {
|
|
if (ptr1 == NULL || ptr2 == NULL) {
|
|
ERROR("or_barray: ptr is NULL");
|
|
}
|
|
if (ptr1->size != ptr2->size) {
|
|
return NULL;
|
|
}
|
|
barray *ptr = create_barray(ptr1->size);
|
|
for (uint i = 0; i < ptr->size; i++) {
|
|
ptr->array[i] = ptr1->array[i] & ptr2->array[i];
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
barray *copy_barray(barray *ptr) {
|
|
if (ptr == NULL) {
|
|
ERROR("copy_barray: ptr is NULL");
|
|
}
|
|
barray *copy = create_barray(ptr->size);
|
|
for (uint i = 0; i < ptr->size_array; i++) {
|
|
copy->array[i] = ptr->array[i];
|
|
}
|
|
return copy;
|
|
}
|