//================================================================================= int CPU_ctor (FILE* BinFile, cpu_t* cpu) { if (cpu == NULL) return CPU_NOT_INITIALIZED; cpu->PM = NULL; cpu->max_counter = 0; cpu->prgm_counter = 0; for (int i = 0; i < MAX_NUM_OF_REGISTERS; i++) cpu->reg[i] = 0; stack_ctor(&cpu->Stack); stack_resize(&cpu->Stack, STACK_SIZE); stack_ctor(&cpu->Address_stack); stack_resize(&cpu->Address_stack, ADDRESS_STACK_SIZE); if (ReadBinaryFile(BinFile, cpu) != CPU_OK) return READING_BINARY_ERROR; int check = CPU_VALID(cpu); if (check != CPU_OK) return check; return CPU_OK; }
Error pop(Stack_t *stack, T* out) { Error *err_temp = NULL; err_temp = my_error_ctor(err_temp); if (is_ok(stack) == 1) { err_temp->code = STACK_NOT_WORK; err_temp->message = "STACK NOT WORK\n"; return *err_temp; } if (stack->pos == 0) { err_temp->code = STACK_UNDERFLOW; err_temp->message = "STACK IS UNDERFLOW\n"; return *err_temp; } my_error_dtor(err_temp); *out = stack->data[--stack->pos]; Error r_resize = stack_resize(stack, 0); if (r_resize.code != NO_ERROR) return r_resize; return *err_temp; }
void test_stack() { printf("\ntesting stack\n"); int c = 16; struct stack* s = stack_create(c); int num = 200; for (int i = 0; i < num; ++i) { stack_push(s, i); } while (!stack_empty(s)) { printf("%d ", stack_pop(s)); } printf("\nresize the stack and test it again\n"); for (int i = 0; i < num; ++i) { stack_push(s, i); } stack_resize(s, 128); for (int i = 0; i < num; ++i) { stack_push(s, i); } while (!stack_empty(s)) { printf("%d ", stack_pop(s)); } stack_destroy(s); }
Error push(Stack_t *stack, T in) { Error *err_temp = NULL; err_temp = my_error_ctor(err_temp); if (is_ok(stack) == 1) { err_temp->code = STACK_NOT_WORK; err_temp->message = "STACK NOT WORK\n"; return *err_temp; } if (stack->pos == stack->len) { Error r_resize = stack_resize(stack, 1); if (r_resize.code != NO_ERROR) return r_resize; } if (is_ok(stack) == 1) { err_temp->code = STACK_NOT_WORK; err_temp->message = "STACK NOT WORK\n"; return *err_temp; } stack->data[stack->pos++] = in; (void)dump(stack); //why do you need dump after each push? my_error_dtor(err_temp); return *err_temp; }
void stack_push(Stack *p, void *data) { if (p->size >= p->cap) { stack_resize(p, p->cap * STACK_RESIZE_FACTOR); } p->elements[p->size] = data; p->size++; }
//returns: 0 if it worked out OK and -1 if something went wrong int stack_reduce_size(struct stack_t *s) { s->size /= 2; if(stack_resize(s) == -1) return -1; return 0; }
//returns: 0 if it worked out OK and -1 if something went wrongZ int stack_increase_size(struct stack_t *s) { s->size *= 2; if(stack_resize(s) == -1) return -1; return 0; }
void stack_push_back(struct stack_t *stack,int value) { if(stack->top < stack->size) { stack->data[stack->top++] = value; } else { stack_resize(stack); stack->data[stack->top++] = value; } }
int push(stack* st, elem_t a) { if (stack_ok(st)) { if (st -> data == st -> size) stack_resize(st); st -> name[st -> data] = a; st -> data++ ; return 0; } else { printf("You will not work with incorrect stack\n"); return 0; } }
int push(stack* st, elem_t a) { if (stack_ok(st)) { if (st -> data < st -> size) // is is always true stack_resize(st); // you always resize??? st -> name[st -> data] = a; st -> data++ ; return 0; } else { printf("You don`t work with incorrect stack\n"); return 0; } }
int stack_pop_back(struct stack_t *stack) { if(stack->top != 0) { --stack->top; if(stack->size > INITIAL_STACK_SIZE) { stack_resize(stack); } return stack->data[stack->top]; } else { printf("Stack is empty!\n"); return INT_MIN; //returns the smallest value of int for empty stack } }
void stack_create(stack_t *stack, process_t *process) { stack->address = MEMORY_USER_STACK_VADDR + process->stack_offset + STACK_LENGTH_MAX; process->stack_offset += STACK_LENGTH_MAX; stack->length = 0; if (UNLIKELY(stack->address >= MEMORY_USER_STACK_VADDR + STACK_PROCESS_MAX)) PANIC("Exceeded maximum number of stacks per process."); uintptr_t old_addr_space = memory_space_get(); if (old_addr_space != process->addr_space) memory_space_switch(process->addr_space); stack_resize(stack, 0x1000, process); if (old_addr_space != process->addr_space) memory_space_switch(old_addr_space); }
int fstack_resize(struct stack_t *stack, size_t size) { return stack_resize(stack, size); }
void stack_dispose(stack_t *stack, process_t *process) { // Resize stack to zero stack_resize(stack, 0, process); }