/* Clears an array and frees its entries
* The entries are freed using the entry_free_function
* This function is not multi-thread safe acquire write lock before call
* Returns 1 if successful or -1 on error
*/
int libcdata_internal_array_clear(
libcdata_internal_array_t *internal_array,
int (*entry_free_function)(
intptr_t **entry,
libcerror_error_t **error ),
libcerror_error_t **error )
{
static char *function = "libcdata_internal_array_clear";
int entry_iterator = 0;
int result = 1;
if( internal_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( internal_array->entries != NULL )
{
for( entry_iterator = 0;
entry_iterator < internal_array->number_of_entries;
entry_iterator++ )
{
if( internal_array->entries[ entry_iterator ] != NULL )
{
if( entry_free_function != NULL )
{
if( entry_free_function(
&( internal_array->entries[ entry_iterator ] ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free array entry: %d.",
function,
entry_iterator );
result = -1;
}
}
internal_array->entries[ entry_iterator ] = NULL;
}
}
}
return( result );
}
/* Resizes an array
* This function is not multi-thread safe acquire write lock before call
* Returns 1 if successful or -1 on error
*/
int libcdata_internal_array_resize(
libcdata_internal_array_t *internal_array,
int number_of_entries,
int (*entry_free_function)(
intptr_t **entry,
libcerror_error_t **error ),
libcerror_error_t **error )
{
void *reallocation = NULL;
static char *function = "libcdata_internal_array_resize";
size_t entries_size = 0;
int entry_iterator = 0;
int number_of_allocated_entries = 0;
int result = 1;
if( internal_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid number of entries value less than zero.",
function );
return( -1 );
}
if( number_of_entries > internal_array->number_of_allocated_entries )
{
/* Pre-allocate in blocks of 16 entries
*/
number_of_allocated_entries = ( number_of_entries & ~( 15 ) ) + 16;
#if SIZEOF_INT <= SIZEOF_SIZE_T
if( (size_t) number_of_allocated_entries > (size_t) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#else
if( number_of_allocated_entries > (int) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid number of allocated entries value exceeds maximum.",
function );
return( -1 );
}
entries_size = sizeof( intptr_t * ) * number_of_allocated_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
return( -1 );
}
reallocation = memory_reallocate(
internal_array->entries,
entries_size );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize array entries.",
function );
return( -1 );
}
internal_array->entries = (intptr_t **) reallocation;
if( memory_set(
&( internal_array->entries[ internal_array->number_of_allocated_entries ] ),
0,
sizeof( intptr_t * ) * ( number_of_allocated_entries - internal_array->number_of_allocated_entries ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
result = -1;
}
internal_array->number_of_allocated_entries = number_of_allocated_entries;
internal_array->number_of_entries = number_of_entries;
}
else if( number_of_entries > internal_array->number_of_entries )
{
internal_array->number_of_entries = number_of_entries;
}
else if( internal_array->entries != NULL )
{
if( entry_free_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry free function.",
function );
return( -1 );
}
for( entry_iterator = number_of_entries;
entry_iterator < internal_array->number_of_entries;
entry_iterator++ )
{
if( internal_array->entries[ entry_iterator ] != NULL )
{
if( entry_free_function != NULL )
{
if( entry_free_function(
&( internal_array->entries[ entry_iterator ] ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free array entry: %d.",
function,
entry_iterator );
result = -1;
}
}
internal_array->entries[ entry_iterator ] = NULL;
}
}
internal_array->number_of_entries = number_of_entries;
}
return( result );
}
/* Resizes an array
* Returns 1 if successful or -1 on error
*/
int libodraw_array_resize(
libodraw_array_t *array,
int number_of_entries,
int (*entry_free_function)(
intptr_t **entry,
libcerror_error_t **error ),
libcerror_error_t **error )
{
void *reallocation = NULL;
static char *function = "libodraw_array_resize";
size_t entries_size = 0;
int entry_iterator = 0;
int result = 1;
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of entries.",
function );
return( -1 );
}
if( number_of_entries > array->number_of_allocated_entries )
{
entries_size = sizeof( intptr_t * ) * number_of_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
return( -1 );
}
reallocation = memory_reallocate(
array->entries,
entries_size );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize array entries.",
function );
return( -1 );
}
array->entries = (intptr_t **) reallocation;
if( memory_set(
&( array->entries[ array->number_of_allocated_entries ] ),
0,
sizeof( intptr_t * ) * ( number_of_entries - array->number_of_allocated_entries ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
result = -1;
}
array->number_of_allocated_entries = number_of_entries;
array->number_of_entries = number_of_entries;
}
else if( number_of_entries > array->number_of_entries )
{
array->number_of_entries = number_of_entries;
}
else if( array->entries != NULL )
{
if( entry_free_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry free function.",
function );
return( -1 );
}
for( entry_iterator = number_of_entries;
entry_iterator < array->number_of_entries;
entry_iterator++ )
{
if( array->entries[ entry_iterator ] != NULL )
{
if( entry_free_function != NULL )
{
if( entry_free_function(
&( array->entries[ entry_iterator ] ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free array entry: %d.",
function,
entry_iterator );
result = -1;
}
}
array->entries[ entry_iterator ] = NULL;
}
}
array->number_of_entries = number_of_entries;
}
return( result );
}