void
sf_push (void)
{
if (_sf_top_ix + 1 >= _sf_max)
_sf_stk = (scanflags_t*) flex_realloc ( (void*) _sf_stk, sizeof(scanflags_t) * (_sf_max += 32));
// copy the top element
_sf_stk[_sf_top_ix + 1] = _sf_stk[_sf_top_ix];
++_sf_top_ix;
}
void *reallocate_array(void *array, int size, size_t element_size)
{
void *new_array;
size_t num_bytes = element_size * size;
new_array = flex_realloc( array, num_bytes );
if ( ! new_array )
flexfatal( _( "attempt to increase array size failed" ) );
return new_array;
}
/* Allocate and initialize an external filter.
* @param chain the current chain or NULL for new chain
* @param cmd the command to execute.
* @param ... a NULL terminated list of (const char*) arguments to command,
* not including argv[0].
* @return newest filter in chain
*/
struct filter *filter_create_ext (struct filter *chain, const char *cmd,
...)
{
struct filter *f;
int max_args;
const char *s;
va_list ap;
/* allocate and initialize new filter */
f = (struct filter *) flex_alloc (sizeof (struct filter));
if (!f)
flexerror (_("flex_alloc failed (f) in filter_create_ext"));
memset (f, 0, sizeof (*f));
f->filter_func = NULL;
f->extra = NULL;
f->next = NULL;
f->argc = 0;
if (chain != NULL) {
/* append f to end of chain */
while (chain->next)
chain = chain->next;
chain->next = f;
}
/* allocate argv, and populate it with the argument list. */
max_args = 8;
f->argv =
(const char **) flex_alloc (sizeof (char *) *
(max_args + 1));
if (!f->argv)
flexerror (_("flex_alloc failed (f->argv) in filter_create_ext"));
f->argv[f->argc++] = cmd;
va_start (ap, cmd);
while ((s = va_arg (ap, const char *)) != NULL) {
if (f->argc >= max_args) {
max_args += 8;
f->argv =
(const char **) flex_realloc (f->argv,
sizeof (char
*) *
(max_args +
1));
}
f->argv[f->argc++] = s;
}
f->argv[f->argc] = NULL;
va_end (ap);
return f;
}
/* reallocate_array - increase the size of a dynamic array */
void *
reallocate_array(void *array, long size, size_t element_size)
{
void *new_array = 0;
if (size > 0) {
size_t num_bytes = element_size * (unsigned) size;
new_array = flex_realloc(array, num_bytes);
}
if (!new_array)
flexfatal(_("attempt to increase array size failed"));
return new_array;
}
static void sko_push(bool dc)
{
if(!sko_stack){
sko_sz = 1;
sko_stack = (struct sko_state*)flex_alloc(sizeof(struct sko_state)*sko_sz);
if (!sko_stack)
flexfatal(_("allocation of sko_stack failed"));
sko_len = 0;
}
if(sko_len >= sko_sz){
sko_sz *= 2;
sko_stack = (struct sko_state*)flex_realloc(sko_stack,sizeof(struct sko_state)*sko_sz);
}
/* initialize to zero and push */
sko_stack[sko_len].dc = dc;
sko_len++;
}
