void
stack_pushstring(struct stack *stack, char *string)
{
stack_grow(stack);
stack->stack[stack->sp].type = BCODE_STRING;
stack->stack[stack->sp].u.string = string;
}
void
stack_pushnumber(struct stack *stack, struct number *b)
{
stack_grow(stack);
stack->stack[stack->sp].type = BCODE_NUMBER;
stack->stack[stack->sp].u.num = b;
}
void stack_push(struct stack *st, void *data)
{
if (st->nr >= st->sz) {
stack_grow(st);
}
memcpy((char *) st->st + st->elemSz * st->nr++, data, st->elemSz);
}
int
stack_push(struct stack *st, void *item)
{
if (stack_grow(st, st->size * 2) < 0)
return -1;
st->item[st->size++] = item;
return 0;
}
/* Insert a new element onto stack */
void
stack_push(Stack stk, ElementAddr elemaddr)
{
ElementAddr target;
if ( stk->loglength == stk->alloclength )
stack_grow(stk);
target = (char *)stk->array + stk->loglength * stk->elemsize;
memcpy(target, elemaddr, stk->elemsize);
stk->loglength++;
}
/* Insert a new data onto stack */
void
push(Stack myStack, MyData myData)
{
MyData target;
if ( myStack->loglength == myStack->alloclength )
stack_grow(myStack);
target = (char *)myStack->array + myStack->loglength * myStack->eleSize;
memcpy(target, myData, myStack->eleSize);
myStack->loglength++;
}
/* Push an item on the top of the stack. */
int stack_push(struct stack *stack, void *data) {
assert(stack != NULL);
if (stack->len <= stack->cap &&
stack_grow(stack, stack->len + 1) != STACK_OK)
return STACK_ENOMEM;
stack->data[stack->len++] = data;
return STACK_OK;
}
int
stack_init(struct stack *st, size_t initial_size)
{
st->item = NULL;
st->size = 0;
st->asize = 0;
if (!initial_size)
initial_size = 8;
return stack_grow(st, initial_size);
}
/* Create new stack with an initialized capacity. */
struct stack *stack_new(size_t cap) {
struct stack *stack = malloc(sizeof(struct stack));
if (stack != NULL) {
stack->data = NULL;
stack->len = 0;
stack->cap = 0;
if (cap > 0 && stack_grow(stack, cap) != STACK_OK) return NULL;
}
return stack;
}
void
stack_push(struct stack *stack, struct value *v)
{
switch (v->type) {
case BCODE_NONE:
stack_grow(stack);
stack->stack[stack->sp].type = BCODE_NONE;
break;
case BCODE_NUMBER:
stack_pushnumber(stack, v->u.num);
break;
case BCODE_STRING:
stack_pushstring(stack, v->u.string);
break;
}
stack->stack[stack->sp].array = v->array == NULL ?
NULL : array_dup(v->array);
}
unsigned stack_grow_to(stack* s, unsigned n)
{
stack_grow(s);
s->c = MAX(s->c, n);
return s->c;
}
