static void expand_segmax(int newsegmax)
{ int32 osize = (int32)segmax * sizeof(char *),
nsize = (int32)newsegmax * sizeof(char *);
synsegbase = (char **)expand_array((VoidStar)synsegbase, osize, nsize);
synsegptr = (char **)expand_array((VoidStar)synsegptr, osize, nsize);
bindsegbase = (char **)expand_array((VoidStar)bindsegbase, osize, nsize);
bindsegptr = (char **)expand_array((VoidStar)bindsegptr, osize, nsize);
segmax = newsegmax;
}
static void save_class(pmix_class_t *cls)
{
if (num_classes >= max_classes) {
expand_array();
}
classes[num_classes] = cls->cls_construct_array;
++num_classes;
}
GArray*
g_array_set_size( GArray *array, guint length )
{
if( length > array->allocated )
if( !expand_array( array, length - array->allocated ) ) return array;
array->len = length;
return array;
}
GArray*
g_array_sized_new( gboolean zero_terminated, gboolean clear,
guint element_size, guint reserved_size )
{
GArray *array = g_array_new( zero_terminated, clear, element_size );
expand_array( array, reserved_size );
return array;
}
GArray*
g_array_append_vals( GArray *array, gconstpointer data, guint len )
{
if( array->len + len > array->allocated )
if( !expand_array( array, len ) ) return array;
memcpy( array->data + array->len * array->element_size,
data,
len * array->element_size );
array->len += len;
return array;
}
/*
* DatumGetExpandedArray: get a writable expanded array from an input argument
*
* Caution: if the input is a read/write pointer, this returns the input
* argument; so callers must be sure that their changes are "safe", that is
* they cannot leave the array in a corrupt state.
*/
ExpandedArrayHeader *
DatumGetExpandedArray(Datum d)
{
/* If it's a writable expanded array already, just return it */
if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
{
ExpandedArrayHeader *eah = (ExpandedArrayHeader *) DatumGetEOHP(d);
Assert(eah->ea_magic == EA_MAGIC);
return eah;
}
/* Else expand the hard way */
d = expand_array(d, CurrentMemoryContext, NULL);
return (ExpandedArrayHeader *) DatumGetEOHP(d);
}
int arraylist_add(arraylist_t *a, void *d, unsigned int l, unsigned int i)
{
if (!a)
return -1;
if (a->size == a->count && expand_array(a) != 0)
return -1;
a->array[i].data = d;
a->array[i].len = l;
a->count++;
fprintf(stderr, "Size: %d, count: %d\n", a->size, a->count);
return 0;
}
// This function inserts the element at the index specified.
void va_insert_element (var_array *var_arr, int index, void *element)
{
int iter;
ASSERT (var_arr);
SC_ASSERT (index >= 0 && index <= var_arr->num_elements);
// If the array is full, expand its size.
if (var_arr->num_elements == (int) var_arr->max_num_elements)
{
expand_array (var_arr);
}
// Move all the elements from index onwards one space forward.
for (iter = var_arr->num_elements - 1; iter >= index; iter--)
{
var_arr->elements[iter+1] = var_arr->elements[iter];
}
var_arr->elements[index] = element;
var_arr->num_elements++;
}
void default_array_init(void)
{
uint8_t i;
for (i = 0; i < PATTERN_COUNT; i++)
{
uint8_t j;
for (j = 0; j < LED_LINE_LENGTH; j++)
{
pattern_array[i][j] = default_pattern_array[i][j];
}
line_array_init(i, (uint8_t *)pattern_array[i]);
}
{
uint8_t mask[LED_LINE_LENGTH];
uint8_t j;
for (j = 0; j < LED_LINE_LENGTH; j++)
{
mask[j] = default_mask[j];
}
expand_array(driver_mask, mask);
}
}
/*
* As above, when caller has the ability to cache element type info
*/
ExpandedArrayHeader *
DatumGetExpandedArrayX(Datum d, ArrayMetaState *metacache)
{
/* If it's a writable expanded array already, just return it */
if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
{
ExpandedArrayHeader *eah = (ExpandedArrayHeader *) DatumGetEOHP(d);
Assert(eah->ea_magic == EA_MAGIC);
/* Update cache if provided */
if (metacache)
{
metacache->element_type = eah->element_type;
metacache->typlen = eah->typlen;
metacache->typbyval = eah->typbyval;
metacache->typalign = eah->typalign;
}
return eah;
}
/* Else expand using caller's cache if any */
d = expand_array(d, CurrentMemoryContext, metacache);
return (ExpandedArrayHeader *) DatumGetEOHP(d);
}
void line_array_init(uint8_t index, uint8_t *value) { expand_array(ir_led_driver_buffer[index], value); }
char *
read_word(char *str, int *buffer_len) {
int c;
int word_length = 0;
static int eof_reached = 0;
str[0] = '\0';
if (eof_reached == 1) {
if (DEBUG)
printf("read_word: eof_reached was %d\n", eof_reached);
return NULL;
}
while ((c = getchar()) != EOF ) {
if (DEBUG)
printf("c was %c, buffer_len is %d, word_length is %d, isspace(c) = %d\n", c, *buffer_len, word_length, isspace(c));
// filter out spaces, tabs, etc.
if (isspace(c) == 0 && c != '\n') {
// if the buffer isn't long enough to
// hold another character, double it
if ( (word_length + 1) > *buffer_len ) {
str = expand_array(&str, buffer_len);
if (str == NULL) {
fprintf(stderr,"read_word: out of memory\n");
exit(1);
}
}
str [word_length++] = c;
// if it is a space, tab, or newline
} else {
// if we have a word in the buffer, return it
if (word_length > 0) {
break;
// if the buffer is empty, keep looking for a word.
} else {
continue;
}
}
}
if (c == EOF) {
// if we have a word in the buffer, return it
if (word_length > 0) {
str[word_length++] = '\0'; // end it with a null char
eof_reached = 1;
return str;
}
if (DEBUG)
printf("caught EOF getting ready to return\n");
return NULL;
}
str[word_length++] = '\0';
if (DEBUG)
printf("word_length: %d, strlen(str): %d, \n", word_length, (int) strlen(str) );
return str;
}
