自学教程：C++ stack_free函数代码示例

void test_move_card_should_not_change_stack_empty_stack_coordinates() {  struct stack *origin, *destination;  struct card *card[2];  card_malloc(&card[0]);  card_malloc(&card[1]);  card_init(card[0]);  card_init(card[1]);  card_set(card[0], ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);  card_set(card[1], KING, HEARTS, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);  stack_malloc(&origin);  stack_malloc(&destination);  stack_init(origin);  stack_init(destination);  stack_push(&origin, card[0]);  stack_push(&destination, card[1]);  move_card(&origin, &destination);  assert(origin->card->frame->begin_y == MANEUVRE_BEGIN_Y);  assert(origin->card->frame->begin_x == MANEUVRE_0_BEGIN_X);  stack_free(origin);  stack_free(destination);}

void test_move_card_from_non_stack_empty_stack_to_non_stack_empty_stack() {  struct stack *origin, *destination;  struct card *card[6];  for (int i = 0; i < 6; i++) {    card_malloc(&card[i]);    card_init(card[i]);    card_set(card[i], TWO + i, i % 5, i % 2, 99, 99);  }  stack_malloc(&origin);  stack_malloc(&destination);  stack_init(origin);  stack_init(destination);  for (int i = 0; i < 3; i++) {    stack_push(&origin, card[i]);  }  for (int i = 3; i < 6; i++) {    stack_push(&destination, card[i]);  }  move_card(&origin, &destination);  assert(stack_length(origin) == 2);  assert(stack_length(destination) == 4);  assert(cards_equal(destination->card, card[2]));  assert(cards_equal(destination->next->card, card[5]));  stack_free(origin);  stack_free(destination);}

void test_valid_move_from_stock_to_maneuvre_stacks() {  struct stack *stock, *maneuvre_stacks[7];  stack_malloc(&stock);  stack_init(stock);  card_set(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);  for (int i = 0; i < 7; i++) {    stack_malloc(&maneuvre_stacks[i]);    stack_init(maneuvre_stacks[i]);  }  card_set(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);  card_set(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);  card_set(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);  card_set(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);  card_set(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);  card_set(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);  card_set(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);  for (int i = 0; i < 7; i++) {    assert(!valid_move(stock, maneuvre_stacks[i]));  }  stack_free(stock);  for (int i = 0; i < 7; i++) {    stack_free(maneuvre_stacks[i]);  }}

void test_move_card_from_stack_empty_stack_to_non_stack_empty_stack() {  struct stack *origin, *destination,               *new_origin, *new_destination,               *origin_duplicate, *destination_duplicate;  struct card *card;  card_malloc(&card);  card_init(card);  card_set(card, ACE, SPADES, EXPOSED, 0, 0);  stack_malloc(&origin);  stack_malloc(&destination);  stack_init(origin);  stack_init(destination);  new_origin = origin;  new_destination = destination;  stack_push(&new_destination, card);  origin_duplicate = stack_dup(origin);  destination_duplicate = stack_dup(destination);  move_card(&new_origin, &new_destination);  assert(origin == new_origin);  assert(stacks_equal(origin, origin_duplicate));  assert(destination == new_destination);  assert(stacks_equal(destination, destination_duplicate));  stack_free(origin);  stack_free(destination);}

/** *  @brief Output moves of an id in a file * *  @return 0 If output was NULL *  @return 1 Otherwise * */int identifier_moves_log(Identifier data, FILE *output) {  if (output == NULL)    return 0;  Stack s, s2;  stack_alloc(&s);  identifier_to_stack(data, &s);  stack_alloc(&s2);  identifier_to_stack(data, &s2);  char strmove[5];  int move = 0, a, b, c, d;  fprintf(output, "MOVES : ");  while ((move = stack_pop(&s)) != -1) {    stack_expand(&a, &b, &c, &d, move);    strmove[0] = a + 'a';    strmove[1] = b + '1';    strmove[2] = c + 'a';    strmove[3] = d + '1';    strmove[4] = '/0';    fprintf(output, "%s ", strmove);  }  fprintf(output, "<-> ");  while ((move = stack_pop(&s2)) != -1) {    fprintf(output, "%d ", move);  }  fprintf(output, "/n");  stack_free(&s2);  stack_free(&s);  return 1;}

void test_valid_move_from_maneuvre_stack_to_waste_pile() {  struct stack *waste_pile, *maneuvre_stacks[7];  stack_malloc(&waste_pile);  stack_init(waste_pile);  card_set(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);  for (int i = 0; i < 7; i++) {    stack_malloc(&maneuvre_stacks[i]);    stack_init(maneuvre_stacks[i]);  }  card_set(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);  card_set(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);  card_set(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);  card_set(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);  card_set(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);  card_set(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);  card_set(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);  for (int i = 0; i < 7; i++) {    assert(!valid_move(maneuvre_stacks[i], waste_pile));  }  stack_free(waste_pile);  for (int i = 0; i < 7; i++) {    stack_free(maneuvre_stacks[i]);  }}

int main(void){    int value = 10, v = 11, i;    Student s1 = {12, "student1", "addr1"},s2 = {13, "student2","a1"},             s3 = {15, "stu3", "address3"}, *sptr;    pStack ps = stack_new(sizeof(Student) + 20);    pStack p = stack_new(sizeof(int));    stack_push(p, &value);    stack_push(p, &v);    printf("%d/n", *((int*)stack_top(p)));    stack_pop(p);    printf("%d/n", *((int*)stack_top(p)));        stack_push(ps, &s1);    stack_push(ps, &s2);    sptr = (pStudent)stack_top(ps);    printf("no: %d, name: %s/n", sptr->no, sptr->addr);    stack_pop(ps);    stack_push(ps, &s3);    sptr = (pStudent)stack_top(ps);    printf("no: %d, name: %s/n", sptr->no, sptr->addr);    stack_free(ps);    for (i = 0; i < 100; i++) {        stack_push(p, &i);    }    for (i = 0; i < 100; i++) {        printf("%d ", *((int*)stack_top(p)));        stack_pop(p);    }    stack_free(p);    exit(EXIT_SUCCESS);}

int main(int argc, char **argv) {	int op;	int number;	stack_t st;	stack_init(&st, INITIAL_STACK_SIZE);	while ((op = get_next_operation(stdin, &number)) != OP_STACK_END) {		if (op == OP_STACK_PUSH) {			stack_push(&st, number);		}		else if (op == OP_STACK_POP) {			if (stack_is_empty(&st)) {				printf("POP from empty stack./n");			}			else {				printf("%d/n", stack_pop(&st));			}		}		else {			fprintf(stderr, "Unexpected operation./n");			stack_free(&st);			exit(EXIT_FAILURE);		}	}	stack_free(&st);	return EXIT_SUCCESS;}

struct stack * type_constrain_ari(struct elt *e1, struct elt *e2){	struct stack *types, *tmp1, *tmp2;	// these will modify the type of e1 and e2 to match arithmetic operation.	// if possible.	if (type_vartype_constrain_ari(e1) == 0) { return NULL; }	if (type_vartype_constrain_ari(e2) == 0) { return NULL; }	if (e1->elttype == E_REG) {		tmp1 = e1->reg->types;	} else {		tmp1 = stack_new();		stack_push(tmp1, &possible_types[(int)e1->cst->type]);	}	if (e2->elttype == E_REG) {		tmp2 = e2->reg->types;	} else {		tmp2 = stack_new();		stack_push(tmp2, &possible_types[(int)e2->cst->type]);	}	types = type_inter(tmp1, tmp2);	if (stack_size(types) == 0) { // float + int		stack_push(types, &possible_types[FLO_T]);	}	if (e1->elttype == E_CST) { stack_free(&tmp1, NULL); }	if (e2->elttype == E_CST) { stack_free(&tmp2, NULL); }	return types;}

void instr_free(void *instruction){	struct instr *i = (struct instr *) instruction;	if (i->optype == I_RAW) { free(i->rawllvm); }	else if (i->optype == I_CAST) {		elt_free(i->res);		elt_free(i->tocast);	}	else if (i->optype == I_CAL) {		free(i->fn);		stack_free(&i->args, elt_free);		stack_free(&i->ret->reg->types, NULL);		elt_free(i->ret);	}	else {		// do not free vr it is used in the global hashmap.		if (i->er != NULL) { elt_free(i->er); }		if (i->e1 != NULL) { elt_free(i->e1); }		if (i->e2 != NULL) { elt_free(i->e2); }	}	free(i);}

void test_valid_move_from_maneuvre_stack_to_foundation_stacks() {  struct stack *foundation_stacks[4];  struct stack *maneuvre_stacks[7];  for (int i = 0; i < 4; i++) {    stack_malloc(&foundation_stacks[i]);    stack_init(foundation_stacks[i]);  }  card_set(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);  card_set(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);  card_set(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);  card_set(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);  for (int i = 0; i < 7; i++) {    stack_malloc(&maneuvre_stacks[i]);    stack_init(maneuvre_stacks[i]);  }  card_set(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);  card_set(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);  card_set(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);  card_set(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);  card_set(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);  card_set(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);  card_set(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);  for (int i = 0; i < 7; i++) {    for (int j = 0; j < 4; j++) {      assert(valid_move(maneuvre_stacks[i], foundation_stacks[j]));    }  }  for (int i = 0; i < 4; i++) {    stack_free(foundation_stacks[i]);  }  for (int i = 0; i < 7; i++) {    stack_free(maneuvre_stacks[i]);  }}

static int type_vartype_constrain_ari(struct elt *e){	int ret = 0;	struct stack *tmp, *inter;	// TODO: Init this only once at the begining	tmp = stack_new();	stack_push(tmp, &possible_types[FLO_T]);	stack_push(tmp, &possible_types[INT_T]);	if (e->elttype == E_REG) {		inter = type_inter(tmp, e->reg->types);		ret = stack_size(inter);		if (ret != 0) {			// replace old stack with the new one			reg_settypes(e->reg, inter);		}		stack_free(&inter, NULL);	} 		else {		if (e->cst->type != FLO_T && e->cst->type != INT_T) {			ret = 0;		} else {			ret = 1;		}	}	stack_free(&tmp, NULL);	return ret;}

void test_valid_move_from_waste_pile_to_stock() {  struct stack *stock, *waste_pile;  stack_malloc(&stock);  stack_malloc(&waste_pile);  stack_init(stock);  stack_init(waste_pile);  card_set(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);  card_set(waste_pile->card, KING, HEARTS, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);  assert(!valid_move(waste_pile, stock));  stack_free(stock);  stack_free(waste_pile);}

/* Removes the element from front of queue */void queuePop(Queue *queue) {  Stack* tmp_ptr = stack(queue->size);  while(size(queue->stk_ptr) > 1) {    push(tmp_ptr, peek(queue->stk_ptr));    pop(queue->stk_ptr);  }  stack_free(queue->stk_ptr);  Stack* tmp_ptr2 = stack(queue->size);  while(!is_empty(tmp_ptr)) {    push(tmp_ptr2, peek(tmp_ptr));    pop(tmp_ptr);  }  stack_free(tmp_ptr);  queue->stk_ptr = tmp_ptr2;}

void stack_print(rpn_stack *stack){    rpn_stack *aux1 = stack, *aux2 = NULL;    int count = stack_count(stack);    while(aux1 != NULL){        stack_push(&aux2, aux1->value);        aux1 = aux1->next;    }    stack_free(&aux1);    while(aux2 != NULL){        printf("%i: %Lf/n", count, aux2->value);        aux2 = aux2->next;        count--;    }    stack_free(&aux2);}

intmain() {  int retval;  char cont;  struct stack *stack;  stack = stack_new(STACK_SIZE);  cont = 1;  while(cont) {    retval = interact(stack);    switch (retval) {    case EXIT_OP:      cont = 0;      break;    case INVALID_CHAR:      printf("Invalid char!/n");      break;    case STACK_UNDERFLOW:      printf("Stack underflow!/n");      break;    case STACK_OVERFLOW:      printf("Stack overflow!/n");      break;    default:      continue;    }  }  stack_free(stack);  return 0;}

void stack_check(){    printf("Testing Stack Functions/n");    Stack *s;    s = stack_init(); assert_i(stack_size(s), 0, "Check Stack Size after init");    stack_push(s, 1, -1); assert_i(stack_size(s), 1, "Check Stack Size after Push");    stack_push(s, 2, -2); assert_i(stack_size(s), 2, "Check Stack Size after Push");    stack_push(s, 3, -3); assert_i(stack_size(s), 3, "Check Stack Size after Push");    int x, y;    stack_pop(s, &x, &y);        assert_p(x, y, 3, -3, "Check Pop");        assert_i(stack_size(s), 2, "Check Size after Pop");    stack_pop(s, &x, &y);        assert_p(x, y, 2, -2, "Check Pop");        assert_i(stack_size(s), 1, "Check Size after Pop");    stack_push(s, 6, -6); assert_i(stack_size(s), 2, "Check Stack Size after Push");    stack_pop(s, &x, &y);        assert_p(x, y, 6, -6, "Check Pop");        assert_i(stack_size(s), 1, "Check Size after Pop");    stack_pop(s, &x, &y);        assert_p(x, y, 1, -1, "Check Pop");        assert_i(stack_size(s), 0, "Check Size after Pop");    stack_free(s);}

struct instr * istore(struct var *vr, struct elt *elt){	struct instr *i;	struct stack *typeinter;	if (elt->elttype == E_REG) {		typeinter = type_inter(vr->t, elt->reg->types);		if (stack_size(typeinter) == 0) {			fprintf(stderr, "Error: Incompatible types in assignment./n");			return NULL;		}		reg_bind(elt->reg, vr);		reg_settypes(elt->reg, typeinter);		stack_free(&typeinter, NULL);		i = instr_new(I_STO, vr, elt, NULL, NULL);	}	else {		stack_clear(vr->t, NULL);		stack_push(vr->t, &possible_types[(int)elt->cst->type]);		i = instr_new(I_STO, vr, elt, NULL, NULL);	}	return i;}

fit_recipe::~fit_recipe(){    seed_list_free(seeds_list);    fit_parameters_free(parameters);    stack_free(stack);    delete ms_setup;}

voidmulti_fit_engine_free(struct multi_fit_engine *f){    int k;    if(f->stack_list) {        for(k = 0; k < f->samples_number; k++) {            if(f->stack_list[k] != NULL) {                stack_free(f->stack_list[k]);            }        }        free(f->stack_list);    }    /* we don't free each spectrum because we are not the owner */    free(f->spectra_list);    /* we don't free f->common_parameters and f->private_parameters       because multi_fit_engine does not own these data */    assert(f->initialized == 0);    free(f);}

void stack_destroy(unsigned long extent) {   struct stack *esp = STACK_PTR; //get the stack pointer  struct stack *to = (struct stack*)extent;  struct variable *var;  while(esp < to) {    /*Pop up the stack */    var = stack_pop();   #ifdef DEBUG    if(var->key) {       err(0,"Removing variable :%s/n",var->key);    }   #endif    stack_free(var); //free up var    esp = STACK_PTR;  //reset stack pointer  }}

/* Create a new thread. It should be passed "fcn", a function which * takes two arguments, (the second one is a dummy, always 4). The * first argument is passed in "arg". Returns the TID of the new * thread */static pid_tcreate_thread(int (*fcn)(void *), void *arg, void **stack){    pid_t newpid;    int flags;    void *my_stack;    my_stack = stack_alloc(THREAD_STACK_SIZE);    /* need SIGCHLD so parent will get that signal when child dies,     * else have errors doing a wait */    flags = SIGCHLD | CLONE_THREAD | CLONE_VM |        /* CLONE_THREAD => no signal to parent on termination; have to use         * CLONE_CHILD_CLEARTID to get that.  Since we're using library call         * instead of raw system call we don't have child_tidptr argument,         * so we set the location in the child itself via set_tid_address(). */        CLONE_CHILD_CLEARTID |        CLONE_FS | CLONE_FILES | CLONE_SIGHAND;    newpid = clone(fcn, my_stack, flags, arg);    /* this is really a tid since we passed CLONE_THREAD: child has same pid as us */    if (newpid == -1) {        fprintf(stderr, "smp.c: Error calling clone/n");        stack_free(my_stack, THREAD_STACK_SIZE);        return -1;    }    *stack = my_stack;    return newpid;}

intmain(){    int i;    sleeptime.tv_sec = 0;    sleeptime.tv_nsec = 10 * 1000 * 1000; /* 10ms */    /* parent remains in own group. creates child who creates a thread group     * and then exits them all     */    for (i = 0; i < NUM_THREADS; i++) {        child_started[i] = false;        child_exit[i] = false;    }    child[0] = create_thread(run, (void *)(long)0, &stack[0], false);    assert(child[0] > -1);    /* wait for child to start rest of threads */    for (i = 0; i < NUM_THREADS; i++) {        while (!child_started[i]) {            /* waste some time: FIXME: should use futex */            nanosleep(&sleeptime, NULL);        }    }    child_exit[0] = true;    while (!child_done[0])        nanosleep(&sleeptime, NULL);    delete_thread(child[0], stack[0]);    for (i = 1; i < NUM_THREADS; i++)        stack_free(stack[i], THREAD_STACK_SIZE);}

/* Create a new thread. It should be passed "fcn", a function which * takes two arguments, (the second one is a dummy, always 4). The * first argument is passed in "arg". Returns the TID of the new * thread */static pid_tcreate_thread(int (*fcn)(void *), void *arg, void **stack, bool same_group){    pid_t newpid;    int flags;    void *my_stack;    my_stack = stack_alloc(THREAD_STACK_SIZE);    /* need SIGCHLD so parent will get that signal when child dies,     * else have errors doing a wait */    flags = SIGCHLD | CLONE_VM |        /* CLONE_THREAD => no signal to parent on termination; have to use         * CLONE_CHILD_CLEARTID to get that.  Since we're using library call         * instead of raw system call we don't have child_tidptr argument,         * so we set the location in the child itself via set_tid_address(). */        CLONE_CHILD_CLEARTID | CLONE_FS | CLONE_FILES | CLONE_SIGHAND;    if (same_group)        flags |= CLONE_THREAD;    /* XXX: Using libc clone in the child here really worries me, but it seems     * to work.  My theory is that the parent has to call clone, which invokes     * the loader to fill in the PLT entry, so when the child calls clone it     * doesn't go into the loader and avoiding the races like we saw in i#500.     */    newpid = clone(fcn, my_stack, flags, arg);    /* this is really a tid if we passed CLONE_THREAD: child has same pid as us */    if (newpid == -1) {        nolibc_print("smp.c: Error calling clone/n");        stack_free(my_stack, THREAD_STACK_SIZE);        return -1;    }    *stack = my_stack;    return newpid;}

voidthread_deallocate(	thread_t			thread){	task_t				task;	if (thread == THREAD_NULL)		return;	if (thread_deallocate_internal(thread) > 0)		return;	ipc_thread_terminate(thread);	task = thread->task;#ifdef MACH_BSD 	{		void *ut = thread->uthread;		thread->uthread = NULL;		uthread_zone_free(ut);	}#endif  /* MACH_BSD */   	task_deallocate(task);	if (thread->kernel_stack != 0)		stack_free(thread);	machine_thread_destroy(thread);	zfree(thread_zone, thread);}

int * inorderTraversal(struct TreeNode *root, int *returnSize){    int idx, *list = (int *)malloc(sizeof(int) * 256); /* ~~, implement a list? */    struct TreeNode *node;    Stack *stack = stack_new(sizeof(struct TreeNode *));    idx = 0;    node = root;    while (node != NULL) {        stack_push(stack, &node);        node = node->left;    }    while (!stack_is_empty(stack)) {        stack_pop(stack, &node);        list[idx++] = node->val;        node = node->right;        while (node != NULL) {            stack_push(stack, &node);            node = node->left;        }    }    stack_free(stack);    *returnSize = idx;    return list;}

struct stack *stack_init(int size){	struct stack *stack = NULL;	if (size < 1) {		return NULL;	}	stack = malloc(sizeof(*stack));	if (!stack) {		goto err;	}	stack->array = calloc(size, sizeof(int));	if (!stack->array) {		goto err;	}	stack->top = -1;	stack->size = size;	return stack;err:	stack_free(stack);	return NULL;}

/* Create a new thread. It should be passed "fcn", a function which * takes two arguments, (the second one is a dummy, always 4). The * first argument is passed in "arg". Returns the PID of the new * thread */static pid_tcreate_thread(int (*fcn)(void *), void *arg, void **stack){    pid_t newpid;     int flags;    void *my_stack;    my_stack = stack_alloc(THREAD_STACK_SIZE);    /* need SIGCHLD so parent will get that signal when child dies,     * else have errors doing a wait */    /* we're not doing CLONE_THREAD => child has its own pid     * (the thread.c test tests CLONE_THREAD)     */    flags = (SIGCHLD | CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND);    newpid = clone(fcn, my_stack, flags, arg, &p_tid, NULL, &c_tid);    if (newpid == -1) {        print("smp.c: Error calling clone/n");        stack_free(my_stack, THREAD_STACK_SIZE);        return -1;    }    *stack = my_stack;    return newpid;}