2007-12-30 17:41:49 +01:00
|
|
|
/***************************************************************************
|
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
gb_array_temp.h
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2022-09-12 15:13:13 +02:00
|
|
|
(c) 2000-2017 Benoît Minisini <benoit.minisini@gambas-basic.org>
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
any later version.
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
|
|
MA 02110-1301, USA.
|
2007-12-30 17:41:49 +01:00
|
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
#define __ARRAY_C
|
|
|
|
|
|
|
|
#include "gb_common.h"
|
|
|
|
#include "gb_error.h"
|
|
|
|
#include "gb_alloc.h"
|
|
|
|
#include "gb_array.h"
|
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
void ARRAY_create_with_size(void *p_data, size_t size, uint inc)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
ARRAY *array;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
ALLOC(&array, sizeof(ARRAY));
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
array->count = 0;
|
|
|
|
array->max = 0;
|
|
|
|
array->size = (uint)size;
|
|
|
|
if (size > 2 && (size & 3))
|
|
|
|
fprintf(stderr, "WARNING: ARRAY_create_with_size: size = %zi\n", size);
|
|
|
|
array->inc = inc;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
*((void **)p_data) = ARRAY_TO_DATA(array);
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-08 21:57:50 +02:00
|
|
|
void ARRAY_delete(void *p_data)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data = (void **)p_data;
|
|
|
|
ARRAY *alloc = DATA_TO_ARRAY(*data);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (!*data)
|
|
|
|
return;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
FREE(&alloc);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
*data = NULL;
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
2022-12-04 20:00:04 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
static inline ARRAY *array_realloc(ARRAY *array)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
ARRAY *new_array;
|
|
|
|
|
|
|
|
array->max = array->inc + ((array->count + array->inc) / array->inc) * array->inc;
|
|
|
|
new_array = array;
|
|
|
|
REALLOC(&new_array, sizeof(ARRAY) + array->max * array->size);
|
|
|
|
return new_array;
|
|
|
|
}
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2022-12-04 20:00:04 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
void *ARRAY_add_data(void *p_data, uint num, bool zero)
|
|
|
|
{
|
|
|
|
void **data = (void **)p_data;
|
|
|
|
ARRAY *array = DATA_TO_ARRAY(*data);
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
array->count += num;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (array->count > array->max)
|
|
|
|
{
|
|
|
|
/*array->max = array->inc + ((array->count + array->inc) / array->inc) * array->inc;
|
|
|
|
new_array = array;
|
|
|
|
REALLOC(&new_array, sizeof(ARRAY) + array->max * array->size);
|
|
|
|
array = new_array;*/
|
|
|
|
array = array_realloc(array);
|
|
|
|
*data = ARRAY_TO_DATA(array);
|
|
|
|
}
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
ptr = (char *)array + sizeof(ARRAY) + array->size * (array->count - num);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (zero) memset(ptr, 0, array->size * num);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
return ptr;
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
2022-12-04 20:00:04 +01:00
|
|
|
|
|
|
|
void ARRAY_realloc(void *p_data)
|
2010-05-29 23:10:36 +02:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data = (void **)p_data;
|
|
|
|
ARRAY *array = DATA_TO_ARRAY(*data);
|
2010-05-29 23:10:36 +02:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
*data = ARRAY_TO_DATA(array_realloc(array));
|
2010-05-29 23:10:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-12-04 20:00:04 +01:00
|
|
|
/*void *ARRAY_add_data_one(void *p_data, bool zero)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data = (void **)p_data;
|
|
|
|
register ARRAY *array = DATA_TO_ARRAY(*data);
|
2010-05-29 23:10:36 +02:00
|
|
|
int size = array->size;
|
2021-12-09 23:50:41 +01:00
|
|
|
char *ptr;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
array->count++;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (array->count > array->max)
|
|
|
|
{
|
|
|
|
array = array_realloc(array);
|
|
|
|
*data = ARRAY_TO_DATA(array);
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr = (char *)array + sizeof(ARRAY) + size * (array->count - 1);
|
2022-12-04 20:00:04 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (zero) memset(ptr, 0, size);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
return ptr;
|
2022-12-04 20:00:04 +01:00
|
|
|
}*/
|
2007-12-30 17:41:49 +01:00
|
|
|
|
|
|
|
|
2009-07-08 21:57:50 +02:00
|
|
|
void ARRAY_remove_last(void *p_data)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data = (void **)p_data;
|
|
|
|
ARRAY *array = DATA_TO_ARRAY(*data);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (!array->count)
|
|
|
|
return;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
array->count--;
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
void *ARRAY_insert_many(void *p_data, int pos, uint count)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data;
|
|
|
|
ARRAY *array;
|
|
|
|
char *addr;
|
|
|
|
int len;
|
|
|
|
uint apos;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
data = (void **)p_data;
|
|
|
|
array = DATA_TO_ARRAY(*data);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if ((pos < 0) || (pos > array->count))
|
|
|
|
apos = array->count;
|
|
|
|
else
|
|
|
|
apos = pos;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
ARRAY_add_many(p_data, count);
|
|
|
|
array = DATA_TO_ARRAY(*data);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
addr = ((char *)(*data)) + array->size * apos;
|
|
|
|
len = (array->count - apos - count) * array->size;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (len > 0)
|
|
|
|
memmove(addr + array->size * count, addr, len);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
memset(addr, 0, array->size * count);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
return addr;
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
void ARRAY_remove_many(void *p_data, int pos, uint count)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
void **data = (void **)p_data;
|
|
|
|
ARRAY *array = DATA_TO_ARRAY(*data);
|
|
|
|
char *addr;
|
|
|
|
int len;
|
|
|
|
uint apos;
|
|
|
|
|
|
|
|
if ((pos < 0) || (pos >= array->count))
|
|
|
|
return;
|
|
|
|
|
|
|
|
apos = pos;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (count < 0 || count > (array->count - apos))
|
|
|
|
count = array->count - apos;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
addr = ((char *)(*data)) + array->size * apos;
|
|
|
|
len = (array->count - apos - count) * array->size;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (len > 0)
|
|
|
|
memmove(addr, addr + array->size * count, len);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
array->count -= count;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (array->max <= array->inc)
|
|
|
|
return;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (array->count > (array->max / 2))
|
|
|
|
return;
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
array->max = ((array->count + array->inc) / array->inc) * array->inc;
|
|
|
|
REALLOC(&array, sizeof(ARRAY) + array->max * array->size);
|
|
|
|
*data = ARRAY_TO_DATA(array);
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-08 21:57:50 +02:00
|
|
|
void ARRAY_qsort(void *data, ARRAY_COMP_FUNC cmp)
|
2007-12-30 17:41:49 +01:00
|
|
|
{
|
2021-12-09 23:50:41 +01:00
|
|
|
ARRAY *array = DATA_TO_ARRAY(data);
|
2007-12-30 17:41:49 +01:00
|
|
|
|
2021-12-09 23:50:41 +01:00
|
|
|
if (array->count)
|
|
|
|
qsort(data, array->count, array->size, cmp);
|
2007-12-30 17:41:49 +01:00
|
|
|
}
|
|
|
|
|