Пример #1
0
/*
** open parts that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  luaS_fix(luaS_newliteral(L, MEMERRMSG));
  g->GCthreshold = 4*g->totalbytes;
}
Пример #2
0
/*
** open parts of the state that may cause memory-allocation errors.
** ('g->version' != NULL flags that the state was completely build)
*/
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  luaS_init(L);
  luaT_init(L);
  luaX_init(L);
  g->gcrunning = 1;  /* allow gc */
  g->version = lua_version(NULL);
  luai_userstateopen(L);
}
Пример #3
0
int main(void) {
    tlsf_create_with_pool(_tlsf_heap, sizeof(_tlsf_heap));

    printf("%s started\n", APPLICATION_NAME);
    xtimer_init();
    msg_init_queue(main_msg_queue, MAIN_MSG_QUEUE_SIZE);
    netdev_init();
    stack_init();
    exp_run();
    printf("%s stopped\n", APPLICATION_NAME);
    return 0;
}
Пример #4
0
int main(int argc, const char **argv)
{
  int opt;

#if 0
  if (argc != 2)
    {
      fprintf(stderr, "Usage: motlle `smottle`\n");
      exit(2);
    }
  sscanf(argv[1], "%p", &load_address);
#endif

  for (;;)
    switch (getopt(argc, argv, "+d"))
      {
      case 'd':
	debug_lvl = 2;
	break;
      case '?':
	break;
      case -1:
	goto done;
      }
 done:

  signal(SIGALRM, silly_sig);

  garbage_init();
  interpret_init();
  stack_init();
  runtime_init();
  call_init();
  parser_init();
  compile_init();
  mcompile_init();
  context_init();
  ports_init();
  if (optind < argc)
    make_global_state(argc - optind, argv + optind);
  else
    make_global_state(0, NULL);
  mudio_init();
  print_init();

  if (optind < argc)
    mload(argv[optind]);
  else
    push_repl();

  for (;;)
    motlle_run1();
}
Пример #5
0
uint32_t *ets_terms_copy_non_recursive_N(term_t *terms, int num,
								uint32_t *htop, t_proc_bin_t **pbs)
{
	uint32_t cradle[256];
	stack_t st;
	stack_init(&st, WSIZE(ets_deferred_copy_t), cradle, 256);

	uint32_t *last_htop = terms_copy(&st, terms, num, htop, pbs);

	stack_done(&st);
	return last_htop;
}
Пример #6
0
static stack *get_saved_pos(void)
{
	static stack st;
	static stack *s;

	if (s == NULL) {
		s = &st;
		stack_init(s, NULL);
	}

	return s;
}
int bst_postOrder(const BisTree *pTree, BNode *pStartNode, Queue *qPostorder) {
	
	BNode *pNode;
	BNode *pLeftChild, *pRightChild;
	Stack stNodesA, stNodesB;
	
	if (pStartNode == 0 || qPostorder == 0)
		return -1;
	
	pNode = 0;
	pLeftChild = pRightChild = 0;
	stack_init(&stNodesA, 0);
	stack_init(&stNodesB, 0);
	stack_push(&stNodesA, (const void *) pStartNode);
	
	while (stack_size(&stNodesA) > 0) {
		
		stack_pop(&stNodesA, (void **) &pNode);
		stack_push(&stNodesB, (const void *) pNode);
		
		pLeftChild = bst_leftChild((const BNode *) pNode);
		pRightChild = bst_rightChild((const BNode *) pNode);
		
		if (pLeftChild != 0) {
			stack_push(&stNodesA, (const void *) pLeftChild);
		}
		if (pRightChild != 0) {
			stack_push(&stNodesA, (const void *) pRightChild);
		}
	}
	
	while (stack_size(&stNodesB) > 0) {
		stack_pop(&stNodesB, (void **) &pNode);
		queue_enqueue(qPostorder, (const void *) pNode);
	}
	
	stack_destroy(&stNodesA);
	stack_destroy(&stNodesB);
	return 0;
}
Пример #8
0
int main(){

	Stack pe, *pe1;
	PilaFloat pilaFloat, *pFloat1;
	init(&pilaFloat);
	stack_init(&pe);
	stack_push(&pe, (void*)10);
	stack_push(&pe, (void*)9);
	stack_push(&pe, (void*)8);
	stack_push(&pe, (void*)7);
	stack_push(&pe, (void*)6);
	stack_push(&pe, (void*)5);
	stack_push(&pe, (void*)4);
	stack_push(&pe, (void*)3);
	stack_push(&pe, (void*)2);
	stack_push(&pe, (void*)1);
	stack_push(&pe, (void*)0);
	stack_push(&pe, (void*)-1);
	stack_push(&pe, (void*)-2);
	stack_push(&pe, (void*)-3);
	stack_push(&pe, (void*)-4);
	push(&pilaFloat, 10.0);
	push(&pilaFloat, 9.0);
	push(&pilaFloat, 8.0);
	push(&pilaFloat, 7.0);
	push(&pilaFloat, 6.0);
	push(&pilaFloat, 5.0);
	push(&pilaFloat, 4.0);
	push(&pilaFloat, 3.0);
	push(&pilaFloat, 2.0);
	push(&pilaFloat, 1.0);
	push(&pilaFloat, 0.0);
	push(&pilaFloat, -1.0);
	push(&pilaFloat, -2.0);
	push(&pilaFloat, -3.0);
	push(&pilaFloat, -4.0);
	pe1 = &pe;
	pFloat1 = &pilaFloat;
	mulPilaPila(&pe, pe1);
	mulPilaPilaF(&pilaFloat, pFloat1);
	while(!stack_empty(&pe)){
		
		printf("%d %f\n", (int)stack_top(&pe), tope(&pilaFloat));
		//printf("OK\n");
		pop(&pilaFloat);
		stack_pop(&pe, 0);
	}
	
	
	
	return 0;
}
Пример #9
0
/**
 *	\ingroup time
 *  TM_AddOneSecond zählt die aktuelle Zeit weiter
 *	und entscheidet auf weiter durchzuführende Aktionen
 */
void TM_AddOneSecond(void)
{
	if (++TM_ss == 60) {
		TM_ss = 0;
		if (++TM_mm == 60) {
			TM_mm = 0;
			// add one hour
			if (++TM_hh == 24) {
				TM_hh = 0;
				TM_AddOneDay();
			}

			// Start der Sommerzeit: März, 2:00:00 ?
			if ((TM_MM==3) && (TM_DOW==0) && (TM_hh==2)) {
                if (TM_DD >= 25 ){		// letzte 7 Tage im Monat ?
                    TM_hh++; 			// 2:00 -> 3:00
                }
            }
			// Ende der Sommerzeit: Oktober, 03:00
			if ((TM_MM==10)  && (TM_DOW==0) && (TM_hh==3) && (TM_DS==0)){
                if (TM_DD >= 25){		// letzte 7 Tage im Monat ?
                    TM_hh--; 			// 3:00 -> 2:00
                    TM_DS=1;			// Marker, dass schon umgestellt ist
                }
			}
        }

		#if USE_SCHEDULER
        // Timer check every 10 minutes
        if ((TM_mm % 10) == 0){
			machineStatus.regeln = 1;
        }
		#endif
 	}

	if (--timerT == 0) {		// Temperaturen messen
		machineStatus.Tlesen = 1;
		timerT = TIME_TEMP;
	}


    if((time_watchdog++) > WTT)
        {
        time_watchdog = 0;
        stack_init();
        }

	#if USE_NTP
	ntp_timer--;
	#endif //USE_NTP

}
Пример #10
0
float	parse_postfix(const char *postfix) {

	char str[INPUT_SIZE], result[ENTRY_SIZE];

	char *temp1, *temp2, *res;
	char *operand, op;
	float a, b, r;
	stack_t stack;


	stack_init(&stack);
	strcpy(str, postfix);
	operand = strtok(str, " ");

	while (operand != NULL) {
		if (is_number(operand[0])) {
			stack_push(&stack, operand);
		} else {
			op = operand[0];
			stack_pop(&stack, &temp1);
			stack_pop(&stack, &temp2);

			sscanf(temp1, "%f", &b);
			sscanf(temp2, "%f", &a);

			switch (op) {
				case '+':
					r = a + b;
					break;
				case '-':
					r = a - b;
					break;
				case '*':
					r = a * b;
					break;
				case '/':
					r = a / b;
					break;

			}
			sprintf(result, "%f", r);

			stack_push(&stack, result);

		}
		operand = strtok(NULL, " ");
	}
	
	stack_pop(&stack, &res);
	r = atof(res);
	return r;
}
Пример #11
0
int main(void) {
	A* a = malloc(sizeof(A)), *b = malloc(sizeof(A)), *c = NULL;
	List* l = list_init();
	Stack* s = stack_init();
	Queue* q = queue_init();
	DoubleLinkedList* d = dll_init();
	printf("a: %d\nB: %d\nc: %d\n", (int)a, (int)b, (int)c);
	a->a1 = 1;
	a->a2 = 'c';
	b->a1 = 2;
	b->a2 = 'a';

	printf("\n=== LIST TEST ===\n");
	list_add(l, a, 0);
	list_append(l, b);
	list_remove(l, 0);
	list_print(l);	
	c = list_get(l, 0);
	printf("c: %d\n", (int)c);
	list_delete(l);

	printf("\n=== STACK TEST ===\n");
	stack_push(s, b);
	stack_push(s, a);
	stack_pop(s);
	stack_print(s);
	c = stack_peek(s);
	printf("c: %d\n", (int)c);
	stack_delete(s);

	printf("\n=== QUEUE TEST ===\n");
	queue_push(q, a);
	queue_push(q, b);
	queue_pop(q);
	queue_print(q);
	c = queue_peek(q);
	printf("c: %d\n", (int)c);
	queue_delete(q);

	printf("\n=== DOUBLE LINKED LIST TEST ===\n");
	dll_add(d, b, 0);
	dll_prepend(d, a);
	dll_remove(d, 1);
	dll_print(d);
	c = dll_get(d, 0);
	printf("c: %d\n", (int)c);
	dll_delete(d);

	free(a);
	free(b);
	return 0;
}
Пример #12
0
int eval(linkedlist *expr, double *val) {

    int i;
    stack_t stk; /* operator stack */

    stack_init(&stk);

    for(i = 0; i < linkedlist_size(expr); i++) {
        token_t *t = linkedlist_get(expr, i);
        token_t *n2, *n1, *res;

        /* if number, push to stack: */
        if (t->type == TOKEN_NUMBER) {
            stack_push(&stk, t);
            continue;
        }

        /* all operators in the postfix expression are binary. */
        if (stack_size(&stk) < 2) {
            while(!stack_isEmpty(&stk))
                free(stack_pop(&stk));
            /* free the remaining tokens in expr: */
            while(i < linkedlist_size(expr))
                free(linkedlist_get(expr, i++));
            return -1; /* error. */
        }
        n2 = stack_pop(&stk);
        n1 = stack_pop(&stk);

        res = malloc(sizeof(token_t));
        res->type = TOKEN_NUMBER;
        res->op   = 0;
        res->num  = do_op(n1->num, n2->num, t->op);
        stack_push(&stk, res);

        free(n2);
        free(n1);
        free(t);
    }

    if (stack_size(&stk) != 1) {
        while(!stack_isEmpty(&stk)) {
            free(stack_pop(&stk));
        }
        return -1; /* error. */
    }

    *val = ((token_t *) stack_peek(&stk))->num;
    free(stack_pop(&stk));
    return 0;

}
Пример #13
0
EntryType eval_expr(char * expr)
{
    char op, c = expr[0];
    int a, b;
    StackPtr OPTR, OPND;  
    
    stack_init(OPTR);
    stack_init(OPND);
    stack_push(OPTR, '#');
    
    while(c != '#' ||  OPTR->top->entry  != '#') {
        if (!is_operand(c)){         // 如果c是操作数
            stack_push(OPND, c);  // 对c进行入栈操作
            expr++;
            c = *expr;
        }
        else{
            switch(prec_compare(OPTR->top->entry, c) ){
                case '<':            // 栈顶元素优先级低于当前运算符
                    push(OPTR, c);    // 将当前运算符入栈
                    expr++;
                    c = *expr;            // 读入下一个字符
                    break;
                case '=':             // 处理括号
                    pop(OPTR, &op);  // 弹出左括号
                    expr++;
                    c = *expr;            // 读入下一个字符
                    break;
                case '>':            // 栈顶元素优先级高于当前运算符
                    pop(OPTR, &op);    // 运算符退栈
                    pop(OPND, &a); pop(OPND, &b);
                    push(OPND, calc(a, b, op));   // 将运算结果入栈
                    break;
            } // end switch
        }
    }// end while
    
    return OPND->top->entry;
}
Пример #14
0
int main(void)
{
    int i;
    stack_t s;
    s = stack_init();

    for (i = 0; i < 2; i++) {
        test(s);
    }

    stack_finalize(s);
    return 0;
}
Пример #15
0
void test_valid_move_from_stock_to_foundation_stacks() {
  struct stack *stock, *foundation_stacks[4];

  stack_malloc(&stock);
  stack_init(stock);
  card_set(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
  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 < 4; i++) {
    assert(!valid_move(stock, foundation_stacks[i]));
  }
  stack_free(stock);
  for (int i = 0; i < 4; i++) {
    stack_free(foundation_stacks[i]);
  }
}
Пример #16
0
void test_valid_move_from_foundation_stack_to_waste_pile() {
  struct stack *waste_pile, *foundation_stacks[4];

  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 < 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 < 4; i++) {
    assert(!valid_move(foundation_stacks[i], waste_pile));
  }
  stack_free(waste_pile);
  for (int i = 0; i < 4; i++) {
    stack_free(foundation_stacks[i]);
  }
}
Пример #17
0
static void test_init(){

  Stack *stack = (Stack *)malloc(sizeof(Stack));
  stack_init(stack, NULL);

  assert(0 == stack_size(stack));
  assert(NULL == stack_peek(stack));
/*
  int *d = (int *)malloc(sizeof(int));
  stack_pop(stack, (void **) &d);
  assert(NULL == d );*/

}
Пример #18
0
lua_State *luaE_newthread (lua_State *L) {
  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
  preinit_state(L1, G(L));
  stack_init(L1, L);  /* init stack */
  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  lua_assert(iswhite(obj2gco(L1)));
  return L1;
}
Пример #19
0
/*
** open parts of the state that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
	global_State *g = G(L);
	//UNUSED(ud);
	stack_init(L, L);  /* init stack */
	//init_registry(L, g);
	//luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
	//luaT_init(L);
	//luaX_init(L);
	///* pre-create memory-error message */
	//g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
	//luaS_fix(g->memerrmsg);  /* it should never be collected */
	//g->gcrunning = 1;  /* allow gc */
}
Пример #20
0
int ar_init (ar * warehouse)
{ /* initialize an ar table */
  if ((*warehouse = (ar) malloc (sizeof (struct ActRecTable))) == NULL) {
    FI_errno = FI_DEFERR;
    return 0;
  }
  if (!stack_init (&((*warehouse) -> entries))) {
    free (*warehouse);
    FI_errno = FI_DEFERR;
    return 0;
  }
  return 1;
}
Пример #21
0
void stk_test_print(void) {
	stack_t* s = stack_init(stk_compare, stk_print, stk_clone, stk_destroy);
	CU_ASSERT (s != NULL);
	
	CU_ASSERT (stack_push(s, stk_test_s1) != NULL);;
	CU_ASSERT (stack_push(s, stk_test_s2) != NULL);;
	CU_ASSERT (stack_push(s, stk_test_s3) != NULL);;
	CU_ASSERT (stack_push(s, stk_test_s4) != NULL);;

	stack_print(s, stdout);

	CU_ASSERT (stack_destroy(s) == 0);
}
Пример #22
0
void stk_test_push(void) {
	stack_t* s = stack_init(stk_compare, stk_print, stk_clone, stk_destroy);
	
	CU_ASSERT (stack_push(NULL, stk_test_s1) == NULL);
	CU_ASSERT (stack_push(s, NULL) == NULL);

	CU_ASSERT (stack_push(s, stk_test_s1) == stk_test_s1);
	CU_ASSERT (stack_push(s, stk_test_s2) == stk_test_s2);
	CU_ASSERT (stack_push(s, stk_test_s3) == stk_test_s3);
	CU_ASSERT (stack_push(s, stk_test_s4) == stk_test_s4);

	CU_ASSERT (stack_destroy(s) == 0);
}
Пример #23
0
/*
** open parts of the state that may cause memory-allocation errors
*/
static void f_killaopen (killa_State *L, void *ud) {
  killa_GlobalState *g = KILLA_G(L);
  KILLA_UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  killaS_resize(L, KILLA_MINSTRTABSIZE);  /* initial size of string table */
  killaT_init(L);
  killaX_init(L);
  /* pre-create memory-error message */
  g->memerrmsg = killaS_newliteral(L, MEMERRMSG);
  killaS_fix(g->memerrmsg);  /* it should never be collected */
  g->gcrunning = 1;  /* allow gc */
}
Пример #24
0
int test_2()
{
    int size = 10000;
    int max = 50000;
    int i, j;
    float aux;
    float val[size];
    struct stack st;
    
    printf("Test 2: %d floats...", size);
    
    for (i = 0; i < size; i++) {
        val[i] = (float)((rand() % max) + 1);
    }
    
    stack_init(&st, sizeof(float));
    
    for (i = 0; i < size; i++) {
        if (stack_push(&st, &val[i]) < 0) {
            printf("error: push\n");
            return -1;
        }
    }
    
    for (j = size - 1; j >= 0; j--) {
        
        if (stack_get_size(&st) == 0) {
            printf("error: size should not be 0\n");
            return -1;
        }
        
        if (stack_pop(&st, &aux) < 0) {
            printf("error: pop\n");
            return -1;
        }
        
        if (aux != val[j]) {
            printf("error: aux (%f) != val[%d] (%f)\n", aux, j, val[j]);
            return -1;
        }
    }
    
    if (stack_get_size(&st) != 0) {
        printf("size %d\n", stack_get_size(&st));
        printf("error: size should be 0\n");
        return -1;
    }
    
    printf(" OK!\n");
    return 0;
}
Пример #25
0
void test_move_card_from_non_stack_empty_stack_to_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 < 6; i++) {
    stack_push(&origin, card[i]);
  }
  move_card(&origin, &destination);

  assert(stack_length(origin) == 5);
  assert(stack_length(destination) == 1);
  assert(cards_equal(destination->card, card[5]));

  move_card(&origin, &destination);

  assert(stack_length(origin) == 4);
  assert(stack_length(destination) == 2);
  assert(cards_equal(destination->card, card[4]));

  move_card(&origin, &destination);

  assert(stack_length(origin) == 3);
  assert(stack_length(destination) == 3);
  assert(cards_equal(destination->card, card[3]));

  stack_free(origin);
  stack_free(destination);
}
Пример #26
0
/**
 * create a new stack
 */
sstack_t *stack_new(void)
{
	sstack_t *stk;

	stk = calloc(1, sizeof *stk);
	if (NULL == stk) {
		ERRF(__FILE__, __LINE__, "ERROR: allocating for a new stack!\n");
		exit(1);
	}

	stack_init(stk);

	return stk;
}
Пример #27
0
Drawing create_drawing() {
	Drawing d = malloc(sizeof(Drawing));

	d->stack = stack_init();
	d->firstLayer = NULL;
	d->lastLayer = NULL;

	if (!d->stack) {
		free(d);
		return NULL;
	}

	return d;
}
Пример #28
0
static void si_init(void) {
    // Create stack for linenumbers
    lineno_stack = dll_init();

    // Initialize scope
    scope_stack = stack_init();

    // Add global scope
    t_scope *tmp = smm_malloc(sizeof(t_scope));
    tmp->context = NULL;
    tmp->depth = 0;
    tmp->entrypoint = NULL;
    stack_push(scope_stack, tmp);
}
Пример #29
0
/* create */
int tpool_init(tpool_t * tp, unsigned int cnt, tfunc controller, tfunc handler)
{
	int i;

#ifdef DEBUG
	assert(NULL != tp);
	assert(NULL != handler);
#endif

	tp->cnt = cnt;
	tp->pool = malloc(tp->cnt * (sizeof *(tp->pool)));
	tp->handler = handler;
	tp->controller = controller;
	tp->jobcount = 0;

	/* set up mutex */
	pthread_mutex_init(&tp->mutex, NULL);

	/* get work queue ready */
	stack_init(&tp->work);

	/* set up the control thread */
	pthread_create(&tp->boss.th, NULL, tp->controller, NULL);
	tp->boss.id = 0;
	tp->boss.job = 0;
	tp->boss.busy = 0;
	pthread_mutex_init(&tp->boss.mt, NULL);
	pthread_mutex_lock(&tp->boss.mt);
	pthread_detach(tp->boss.th);

	for (i = 0; i < (signed)tp->cnt; ++i) {
		if (pthread_create
		    (&tp->pool[i].th, NULL, tp->handler, (void *)i)) {
			/* trouble... */
			ERRF(__FILE__, __LINE__,
			     "error creating thread %d in pool.\n", i);
			return 0;
		}

		/* automatic cleanup */
		tp->pool[i].id = i;
		tp->pool[i].job = 0;
		tp->pool[i].busy = 0;
		pthread_mutex_init(&tp->pool[i].mt, NULL);
		pthread_mutex_lock(&tp->pool[i].mt);
		pthread_detach(tp->pool[i].th);
	}

	return 1;
}
Пример #30
0
static void postfix_infix(const char *postfix)
{
    assert(postfix != 0);
    printf("Postfix expression: %s\n", postfix);
    char c;
    bool valid = true;
    Stack stack;

    stack_init(&stack);
    while ((c = *postfix++) != '\0')
    {
        if (isdigit(c))
            stack_push_chr(&stack, c);
        else if (is_operator(c))
        {
            char *rhs = stack_pop(&stack);
            char *lhs = stack_pop(&stack);
            size_t l_rhs = strlen(rhs);
            size_t l_lhs = strlen(lhs);
            char expr[l_lhs + l_rhs + sizeof("()*()")];
            snprintf(expr, sizeof(expr), "%s%s%s%c%s%s%s",
                    (l_lhs > 1) ? "(" : "", lhs, (l_lhs > 1) ? ")" : "", c,
                    (l_rhs > 1) ? "(" : "", rhs, (l_rhs > 1) ? ")" : "");
            stack_push_str(&stack, expr);
            free(lhs);
            free(rhs);
        }
        else if (isspace(c))
            continue;
        else
        {
            err_remark("Invalid character %c (0x%.2X) found\n", c, c);
            valid = false;
            break;
        }
    }

    if (valid)
    {
        if (stack.tos != 1)
            err_remark("Stack has wrong number of entries (%zu instead of 1)\n", stack.tos);
        else
        {
            char *infix = stack_pop(&stack);
            printf("Infix expression: %s\n", infix);
            free(infix);
        }
    }
    stack_free(&stack);
}