Beispiel #1
0
void slist_insert(SList *plist, unsigned int ipos, char *pdata, size_t isize)
{
    ipos = ipos > plist->icount ? plist->icount : ipos;
    if (ipos == plist->icount)
        slist_push(plist, pdata, isize);
    else
    {
        ListNode *pnew = slistnode_create(pdata, isize);
        ListNode *pbefore = plist->pfirst;
        for (int i = 0; i < ipos-1; i++)
            pbefore = pbefore->pnext;
        ListNode *pafter = pbefore->pnext;
        pbefore->pnext = pnew;
        pnew->pnext = pafter;
        plist->icount++;
    }
}
Beispiel #2
0
int main(int argc, char *argv[])
{
	struct slist *list;

	list = slist_new();
	assert(list);

	assert(0 == slist_size(list));

	assert(list == slist_idx(list, 0));

	assert(NULL == slist_idx(list, -1));

	assert(NULL == slist_idx(list, 1));

	/* Build an array and set canary values */
	struct slist *nodes1[NODECNT];
	for (int i = 0; i < NODECNT; i++) {
		nodes1[i] = malloc(sizeof(struct slist));
		nodes1[i]->s = malloc(sizeof(struct sample));
		nodes1[i]->s->rx_bytes = i;
	}

	/* Then add array elements to a list */
	for (int i = 0; i < NODECNT; i++) {
		slist_push(list, nodes1[i]);

		assert(1 + i == slist_size(list));
	}

	/* check slist_size */
	assert(NODECNT == slist_size(list));

	/* check the list_idx function */
	for (int i = 0; i < NODECNT; i++) {
		struct slist *n = slist_idx(list, i);
		assert(n);
		assert(n->s->rx_bytes == i);
	}

	/* check slist_clear */
	slist_clear(list);
	assert(0 == slist_size(list));

}
Beispiel #3
0
static int frames_to_sample_list()
{
	int new_samples = 0;

	pthread_mutex_lock(&unsent_frame_count_mutex);
	while (g_unsent_frame_count > 0) {
		for (int i = 0; i < SAMPLES_PER_FRAME; i++) {
			struct sample *s = malloc(sizeof(struct sample));
			assert(s);
			memcpy(s, &(g_raw_samples->samples[i]),
			       sizeof(struct sample));
			struct slist *ln = malloc(sizeof(struct slist));
			assert(ln);
			ln->s = s;
			slist_push(sample_list, ln);
			g_sample_count++;
			new_samples++;
		}
		g_unsent_frame_count--;
	}
	pthread_mutex_unlock(&unsent_frame_count_mutex);

	int overflow = (slist_size(sample_list) > MAX_LIST_LEN)
	                   ? slist_size(sample_list) - MAX_LIST_LEN
	                   : 0;

	while (overflow--) {
		struct slist *ln = slist_pop(sample_list);
		assert(ln);
		assert(ln->s);
		free(ln->s);
		free(ln);
	}

	if (g_sample_count > MAX_LIST_LEN) {
		g_sample_count -= MAX_LIST_LEN;
	}
	return new_samples;
}
Beispiel #4
0
// --------------------- Evaluation of the final Position ---------------------
void final_status_list(Position *pos, Status block_status[MAX_BLOCKS], 
       Status point_status[BOARDSIZE], char *str_st, Point points[BOARDSIZE])
// Compute the status of all points (evaluation from owner_map[])
{
    Block b;
    Status st;

    for (char *p=str_st ; *p != 0 ; p++) 
        *p = tolower(*p);

    if (strcmp(str_st, "dead") == 0)
        st = DEAD;
    else if (strcmp(str_st, "alive") == 0)
        st = ALIVE;
    else
        st = UNKNOWN;

    slist_clear(points);
    FORALL_POINTS(pos, pt) {
        b = point_block(pos, pt);
        if (b != 0  && block_status[b] == st)
                slist_push(points, pt);
    }
Beispiel #5
0
char* do_play(Game *game, Color c, Point pt)
// Play the move (updating the Game struct)
{
    char *ret;
    Color to_play_before;
    int   played=0;
    Info  m = 0;
    Position *pos = game->pos;

    to_play_before = board_color_to_play(pos);
    board_set_color_to_play(pos, c);

    if (point_color(pos,pt) == EMPTY) {
        ret = play_move(pos, pt);
        if (ret[0] == 0) {
            m = pt + (board_captured_neighbors(pos) << 9) 
                   + (board_ko_old(pos) << 13) 
                   + ((to_play_before) << 22);
            played = 1;
        }
        // else illegal move: nothing played
    }
    else if(pt == PASS_MOVE) {
        ret = pass_move(pos);
        m = pt + (board_captured_neighbors(pos) << 9) 
               + (board_ko_old(pos) << 13) 
               + ((to_play_before) << 22);
        played = 1;
    }
    else ret ="Error Illegal move: point not EMPTY\n";
    if (played) {
        c2++;
        slist_push(game->moves, m);
    }
    return ret;
}
Beispiel #6
0
/*
 * in         - Source file to be interpreted
 * file_name  - Name of the source file, for debugging purposes
 * sym_table  - Global (master) symbol table
 */
void liten(FILE * in, char * file_name, slist * sym_table, token ** ret) {
    
  // *ret = NULL;

  slist * block_stack = slist_init();

  slist * local_table = slist_init();
  slist_push(sym_table, local_table);

  file_desc * desc = malloc(sizeof(file_desc));
  desc->file = in;
  desc->name = file_name;
  desc->line = 1;

  int tok;
  char * temp = malloc(sizeof(char)*MAX_STR);
  strcpy(temp, "\0");
  int type = -1;
  slist * tok_queue = slist_init();

  while (1) {
    if (in == stdin) {
      printf(":> ");
    } else if (tok == EOF) {
      break;
    }
    tok = getc(in);
    while (1) {
      if (tok == '\n' || tok == EOF) {
        desc->line++;
        tokenize(desc, &temp, &type, tok_queue);
        type = -1;
        // slist_print(tok_queue, slist_print_token);
        // TODO: Check line for syntax errors
        if (tok_queue->len == 0) break;
        if (block_stack->len == 0) {
          rpn(desc, tok_queue, sym_table, block_stack, ret);
        } else {
          char * temp_str = ((token *) slist_get(tok_queue, 0)->obj)->obj;
          block * temp = (block *) slist_get(block_stack, -1)->obj;
          if (strcmp("end", temp_str) == 0) {
	          rpn(desc, tok_queue, sym_table, block_stack, ret);
          } else if (strcmp("if", temp_str) == 0 ||
	          strcmp("while", temp_str) == 0) {
	          if (temp->value == 1)
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
	          else {
	            block * temp1 = malloc(sizeof(block));
	            temp1->value = 0;
	            if (strcmp("if", temp_str) == 0) {
		            temp1->type = IF_B;
	            } else if (strcmp("while", temp_str) == 0) {
		            temp1->type = WHILE_B;
	            }
	            slist_push(block_stack, temp1);
	          }
          } else if (strcmp("elif", temp_str) == 0) {
	          if (temp->type != IF_B) lite_error(desc, "'elif' exists in 'if' block");
	          if (temp->value == 1) temp->value = 0;
	          else
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
          } else if (strcmp("else", temp_str) == 0) {			
	          if (temp->type != IF_B) lite_error(desc, "'else' exists in 'if' block");
	          if (temp->value == 1) temp->value = 0;
	          else temp->value = 1;
          } else {
	          if (temp->value == 1)
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
          }
        }
        
        tok_queue = slist_init();
        
        } else {
          token_parse(desc, tok, &temp, &type, tok_queue);
        }
         
        if (in == stdin && tok == '\n') break;
        tok = getc(in);
      }
    }

    return;
}
Beispiel #7
0
void PropValue(void)
// PropValue = "[" ValueType "]"
{
    yyaccept('['); ValueType();

    // Property Value was read : use it to modify the game
    int size = board_size(game->pos);
    if (board_nmoves(game->pos) < nmoves-1 
        && strcmp(prop_name[prop], "B") == 0) {
        if (yytext[0] != 'B')
            do_play(game, BLACK, parse_sgf_coord(yytext, size));
        else
            do_play(game, BLACK, PASS_MOVE);
    }
    else if (board_nmoves(game->pos) < nmoves-1 
        && strcmp(prop_name[prop], "W") == 0) {
        if (yytext[0] != 'W')
            do_play(game, WHITE, parse_sgf_coord(yytext, size));
        else
            do_play(game, WHITE, PASS_MOVE);
    }
    else if (strcmp(prop_name[prop], "AB") == 0) {
        Point pt = parse_sgf_coord(yytext, size);
        slist_push(game->placed_black_stones, pt);
        board_place_stone(game->pos, pt, BLACK);
    }
    else if (strcmp(prop_name[prop], "AW") == 0) {
        Point pt = parse_sgf_coord(yytext, size);
        slist_push(game->placed_white_stones, pt);
        board_place_stone(game->pos, pt, WHITE);
    }
    else if (strcmp(prop_name[prop], "KM") == 0)
        board_set_komi(game->pos, atof(yytext));
    else if (strcmp(prop_name[prop], "SZ") == 0) {
        if (is_game_board_empty(game)) { 
            board_set_size(game->pos, atoi(yytext));
            game_clear_board(game);
        }
        else {
            // Can happen if SZ occurs after AB or AW
            Point    bstones[BOARDSIZE], wstones[BOARDSIZE];
            Position *pos=game->pos;

            slist_clear(bstones); slist_clear(wstones);
            slist_append(bstones, game->placed_black_stones);
            slist_append(wstones, game->placed_white_stones);

            board_set_size(game->pos, atoi(yytext));
            game_clear_board(game);
            
            FORALL_IN_SLIST(bstones, pt) {
                board_set_color_to_play(pos, BLACK);
                play_move(pos, pt);
                slist_push(game->placed_black_stones, pt);
            }
            FORALL_IN_SLIST(wstones, pt) {
                board_set_color_to_play(pos, WHITE);
                play_move(pos, pt);
                slist_push(game->placed_white_stones, pt);
            }
        }