Example #1
0
/*
 * pool_hdr_preliminary_check -- (internal) check pool header checksum and pool
 *	parameters
 */
static int
pool_hdr_preliminary_check(PMEMpoolcheck *ppc, location *loc)
{
	LOG(3, NULL);

	CHECK_INFO(ppc, "%schecking pool header", loc->prefix);

	if (util_is_zeroed((void *)&loc->hdr, sizeof(loc->hdr))) {
		if (CHECK_IS_NOT(ppc, REPAIR)) {
			check_end(ppc->data);
			ppc->result = CHECK_RESULT_NOT_CONSISTENT;
			return CHECK_ERR(ppc, "%sempty pool hdr", loc->prefix);
		}
	} else if (loc->hdr_valid) {
		enum pool_type type = pool_hdr_get_type(&loc->hdr);
		if (type == POOL_TYPE_UNKNOWN) {
			if (CHECK_IS_NOT(ppc, REPAIR)) {
				check_end(ppc->data);
				ppc->result = CHECK_RESULT_NOT_CONSISTENT;
				return CHECK_ERR(ppc, "%sinvalid signature",
					loc->prefix);
			}

			CHECK_INFO(ppc, "%sinvalid signature", loc->prefix);
		} else {
			/* valid check sum */
			CHECK_INFO(ppc, "%spool header correct",
				loc->prefix);
			loc->step = CHECK_STEP_COMPLETE;
			return 0;
		}
	} else if (CHECK_IS_NOT(ppc, REPAIR)) {
		check_end(ppc->data);
		ppc->result = CHECK_RESULT_NOT_CONSISTENT;
		return CHECK_ERR(ppc, "%sincorrect pool header", loc->prefix);
	} else {
		CHECK_INFO(ppc, "%sincorrect pool header", loc->prefix);
	}

	ASSERT(CHECK_IS(ppc, REPAIR));

	if (ppc->pool->params.type == POOL_TYPE_UNKNOWN) {
		ppc->pool->params.type = pool_hdr_possible_type(ppc);
		if (ppc->pool->params.type == POOL_TYPE_UNKNOWN) {
			ppc->result = CHECK_RESULT_CANNOT_REPAIR;
			return CHECK_ERR(ppc, "cannot determine pool type");
		}
	}

	if (!pool_supported(ppc->pool->params.type)) {
		ppc->result = CHECK_RESULT_CANNOT_REPAIR;
		return CHECK_ERR(ppc, "the repair of %s pools is not supported",
			pool_get_pool_type_str(ppc->pool->params.type));
	}

	return 0;
}
Example #2
0
 bool loop_check(long read_size) {
   if (loop_) {
     if (check_end(read_size)) {
       set_loop_start();
     }
   } else {
     if (check_end(read_size)) {
       end_ = true;
       return true;
     }
   }
   return false;
 }
Example #3
0
int		epur_fct(char *str, t_epur *e)
{
  while (str[e->i] == ' ' && str[e->i] != '\0')
    e->i++;
  while (str[e->i] != '\0')
    {
      while ((str[e->i] == ' ' && str[e->i + 1] == ' ') ||
	     (str[e->i] == '\t' && str[e->i + 1] == '\t'))
	e->i++;
      if ((e->tmp = epur_single(str, e)) != NULL)
	{
	  e->tmp[e->k] = str[e->i];
	  e->k++;
	  e->i++;
	}
      else
	return (-1);
      e->tmp[e->k] = '\0';
    }
  e->tmp = check_end(str, e);
  if (check_start(e->tmp) == -1 || epur_end(str) == -1)
    return (-1);
  else
    return (1);
}
Example #4
0
char		kongjumpright(char **map, char c, t_pict *pict)
{
  int		x, y;
  char		sauv = c;

  x = 0;
  y = 0;
  while (map[x][y] != 'i' && map[x][y] != 'j') {
    if (map[x][y] == '\n')
      {
        y = 0;
        x++;
      }
    y++;
  }
  if (map[x - 1][y] != 'w' || map[x -1][y] == 'k')
    sauv = kongjumpright_2(x, y, c, map, pict);
  if (sauv == 'o' && (check_end(map) == 1))
    donkey_win(pict->win);
  fall(map, pict);
  if (sauv == 'n' || sauv == 'm' || sauv == 'k')
    {
      if (c != 's')
	sauv = '.';
    }
  return (sauv);
}
Example #5
0
void		draw(t_env *e)
{
	t_vect2i	p;
	t_vect2i	s;

	s = set_vect2i((COLS - 1) / 4, (LINES - 1) / 4 - 1);
	draw_ui(ft_itoa(e->score), s);
	p.y = -1;
	check_end(e->score, e->map);
	while (++p.y <= (s.y * 4) + 1)
	{
		p.x = -1;
		while (++p.x <= (s.x * 4))
		{
			if (p.x < (s.x * 4) && (p.y % (s.y) == 0 || p.y == (s.y * 4)))
			{
				while (p.x < (s.x * 4))
					mvprintw(p.y + 3, p.x, ((p.x++) % (s.x) == 0) ? "+" : "-");
				mvprintw(p.y + 3, p.x, "+");
			}
			else if (p.y < (s.y * 4)
						&& (p.x % (s.x) == 0 || p.x == (s.x * 4)))
				mvprintw(p.y + 3, p.x, "|");
		}
	}
	draw_numbers(e->map, s);
}
Example #6
0
blargg_err_t Vgm_Emu::run_clocks( blip_time_t& time_io, int msec )
{
	check_end();
	time_io = core.run_psg( msec );
	check_warning();
	return (blargg_err_t)blargg_ok;
}
Example #7
0
File: loop.c Project: tmerlier/2048
static int		exec_key(t_env *env, int key)
{
	int			ret_move;
	int			ret_end;

	if (key == 27)
		return (1);
	else if (key == KEY_UP || key == KEY_LEFT
			|| key == KEY_RIGHT || key == KEY_DOWN)
	{
		ret_move = move_plate(env, key);
		if (ret_move != -1)
		{
			env->score += ret_move;
			pop_new(env->plate, env->size);
		}
		ret_end = check_end(env);
		if (ret_end == -1)
			return (1);
	}
	else if (key == 'u' && env->undo-- > 0)
		dup_plate(env->plate, env->last_plate, env->size);
	else if (key == KEY_F(1))
		save_plate(env);
	else if (env->ascii.ascii_on && key >= '1' && key <= MAX_ASCII + '0')
		load_ascii(env, key - '0');
	return (0);
}
Example #8
0
inline int Vgm_Emu::play_frame( blip_time_t blip_time, int sample_count, sample_t buf [] )
{
	check_end();
	int result = core.play_frame( blip_time, sample_count, buf );
	check_warning();
	return result;
}
Example #9
0
/*
 * sds_check -- (internal) check shutdown_state
 */
static int
sds_check(PMEMpoolcheck *ppc, location *loc)
{
	LOG(3, NULL);

	CHECK_INFO(ppc, "%s" SDS_CHECK_STR, loc->prefix);

	/* shutdown state is valid */
	if (!sds_check_replica(loc)) {
		CHECK_INFO(ppc, "%s" SDS_OK_STR, loc->prefix);
		loc->step = CHECK_STEP_COMPLETE;
		return 0;
	}

	/* shutdown state is NOT valid and can NOT be repaired */
	if (CHECK_IS_NOT(ppc, REPAIR)) {
		check_end(ppc->data);
		ppc->result = CHECK_RESULT_NOT_CONSISTENT;
		return CHECK_ERR(ppc, "%s%s", loc->prefix,
				SDS_FAIL_MSG(&loc->hdr));
	}

	/* shutdown state is NOT valid but can be repaired */
	CHECK_ASK(ppc, Q_RESET_SDS, "%s%s", loc->prefix,
			SDS_REPAIR_MSG(&loc->hdr));
	return check_questions_sequence_validate(ppc);
}
Example #10
0
File: combat.c Project: rj76/kq
/*! \brief Choose an action
 * \author Josh Bolduc
 * \date Created ????????
 * \date Updated
 *
 * Choose a fighter action.
 */
static void do_action (int dude)
{
   int index;

   for (index = 0; index < 2; index++)
      if (fighter[dude].imb[index] > 0)
         cast_imbued_spell (dude, fighter[dude].imb[index], 1, TGT_CASTER);

   if (fighter[dude].sts[S_MALISON] > 0) {
      if ((rand () % 100) < fighter[dude].sts[S_MALISON] * 5)
         cact[dude] = 0;
   }

   if (fighter[dude].sts[S_CHARM] > 0) {
      fighter[dude].sts[S_CHARM]--;

      if (dude < PSIZE)
         auto_herochooseact (dude);
      else
         enemy_charmaction (dude);
   }

   if (cact[dude] != 0) {
      revert_cframes (dude, 0);
      if (dude < PSIZE) {
         if (fighter[dude].sts[S_CHARM] == 0)
            hero_choose_action (dude);
      } else
         enemy_chooseaction (dude);
   }

   cact[dude] = 0;
   if (check_end () == 1)
      combatend = 1;
}
Example #11
0
void ram(void) {
	while(1) {
		if (!screen_intro()){
      setTextColor(0xff,0x00);
      return;
    }
		game.rokets = 3;
		game.level = 1;
		game.score = 0;
		init_game();
		screen_level();
		while (game.rokets>=0) {
			////checkISP();
			lcdFill(0x00);
			check_end();
			move_ufo();
			move_shot();
			move_shots();
			move_player();
			move_enemy();
			draw_score();
			draw_ufo();
			draw_bunker();
			draw_player();
			draw_enemy();
			draw_shots();
			//        draw_status();
			lcdDisplay();
			delayms(12);
		}
		if (!screen_gameover())
      setTextColor(0xff,0x00);
      return;
	}
}
Example #12
0
static int	move(t_server *server)
{
  double	diff;

  diff = (double)SPEED * (double)TIMEOUT;
  diff /= (double)1000000;
  server->players->x += diff;
  server->players->next->x += diff;
  move_vertical(server, server->players);
  move_vertical(server, server->players->next);
  check_coin(server, server->players, server->players->x, server->players->y);
  check_coin(server, server->players, server->players->x + 0.99,
	     server->players->y);
  check_coin(server, server->players, server->players->x,
	     server->players->y + 0.99);
  check_coin(server, server->players, server->players->x + 0.99,
	     server->players->y + 0.99);
  check_coin(server, server->players->next, server->players->next->x,
	     server->players->next->y);
  check_coin(server, server->players->next, server->players->next->x + 0.99,
	     server->players->next->y);
  check_coin(server, server->players->next, server->players->next->x,
	     server->players->next->y + 0.99);
  check_coin(server, server->players->next, server->players->next->x + 0.99,
	     server->players->next->y + 0.99);
  return (check_end(server));
}
Example #13
0
    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
    {
        traits::clear<MultiGeometry>::apply(geometry);

        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
        tokenizer::iterator it;
        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it))
        {
            handle_open_parenthesis(it, tokens.end(), wkt);

            // Parse sub-geometries
            while(it != tokens.end() && *it != ")")
            {
                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
                Parser
                    <
                        typename boost::range_value<MultiGeometry>::type
                    >::apply(it, tokens.end(), wkt, *(boost::end(geometry) - 1));
                if (it != tokens.end() && *it == ",")
                {
                    // Skip "," after multi-element is parsed
                    ++it;
                }
            }

            handle_close_parenthesis(it, tokens.end(), wkt);
        }
        
        check_end(it, tokens.end(), wkt);
    }
 inline void increment()
 {
     if (this->base() != m_end)
     {
         (this->base_reference())++;
         check_end();
     }
 }
Example #15
0
int main(int argv, char** argc)
{
  check_init();
  check_start("clib -- libdatrie -- trie");
  test_trie_tree_states();
  test_datrie_states();
  test_datrie();
  check_end();
  check_close();
  return 0;
}
    // warning! geometry must be empty!
    static inline void apply(std::string const& wkt, Geometry& geometry)
    {
        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;

        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
        tokenizer::iterator it = tokens.begin();
        tokenizer::iterator end = tokens.end();

        Parser<Geometry>::apply(it, end, wkt, geometry);
        check_end(it, end, wkt);
    }
Example #17
0
form *
sendanswer_1_svc(form *argp, struct svc_req *rqstp)
{
	static form  result;

	
	if(current_user == manager) //se processo corrente e o coordenador recebendo respostas
	{
		printf("Coordenador recebeu respostas de %s\n", argp->attr.address);
		if(find_by_address(argp->attr) >= 0)
		{
			printf("1\n");
			int index = find_by_address(argp->attr);
			printf("2\n");
			int formsize = sizeof(form);
			printf("3\n");
			memcpy(&answer[index], argp, formsize);
			printf("4\n");
			count_answer[index] = 1;
			printf("5\n");
			check_end();
			printf("6\n");
		}
	}
	else //se processo corrente recebe resposta do cliente, a envia para o coordenador
	{
		questions_answered++;
		printf("Cliente enviando respostas ao coordenador\n");
		memcpy(&answer[current_user],argp,sizeof(form));

		CLIENT *clnt;
		form  *result_4;
		form  sendanswer_1_arg;

		memcpy(&sendanswer_1_arg, &answer[current_user], sizeof(form));

		char *host = list[manager].ip;
		printf("host: %s usuario numero: %d\n",host,manager);
		clnt = clnt_create (host, PROGJOGO, VERJOGO, "udp");
		if (clnt == NULL) {
			reset = 1;
		}
		strcpy(sendanswer_1_arg.attr.address, list[current_user].ip);
		result_4 = sendanswer_1(&sendanswer_1_arg, clnt);
		if (result_4 == (form *) NULL) {
			reset = 1;
		}
		//manda pro grandao
		//falta tratamento caso o coordenador esteja morto
	}
	return &result;
}
Example #18
0
File: game.c Project: plean/CPE
void	aff_promt(t_prog_base *base)
{
  aff_message(base, 1);
  if ((base->nb_deleted[base->line - 1] += base->matches) ==
      base->matches_per_lines[base->line - 1])
    base->is_empty[base->line - 1] = 1;
  print_screen(base);
  check_end(base, 1);
  if (base->is_ended == 1)
    return ;
  my_putstr("\nIA's turn...\n", 1);
  my_ia(base);
  aff_message(base, 2);
  if ((base->nb_deleted[base->line - 1] += base->matches) ==
      base->matches_per_lines[base->line - 1])
    base->is_empty[base->line - 1] = 1;
  print_screen(base);
  check_end(base, 2);
  if (base->is_ended == 1)
    return ;
  my_putstr("\nYour turn:", 1);
}
Example #19
0
infoperson *
nicetomeetyou_1_svc(infoperson *argp, struct svc_req *rqstp)
{
	static infoperson  result;
	if(argp->attr.booleanVar != 1)
	{
		printf("Verificando se hosts estao vivos\n");
		CLIENT *clnt;
		infoperson  *result_5;
		 infoperson  nicetomeetyou_1_arg;
	
		char *host;
		int i;
		nicetomeetyou_1_arg.attr.booleanVar = 1;
		for(i=0;i<10;i++)
		{
			if(current_user != i)
			{
				host = list[i].ip;
	
				clnt = clnt_create (host, PROGJOGO, VERJOGO, "udp");
				if (clnt == NULL) {
					printf("Host %s nao esta respondendo\n",host);
					list[i].keepAlive = 0;
					check_end();	
				}

				result_5 = nicetomeetyou_1(&nicetomeetyou_1_arg, clnt);
                        	if (result_5 == (infoperson *) NULL) {
					printf("Host %s nao esta respondendo\n",host);
					list[i].keepAlive = 0;
					check_end();
				}
			}
		}
	}
	return &result;
}
Example #20
0
File: main2.c Project: finet-f/git
void	my_ls3(int ac, char **av, int i, int *tab)
{
  int	r;

  ac = ac + i - 1;
  my_ls31(ac, av, i);
  while (i < ac)
    {
      r = my_ls32(av, i, tab);
      if (check_end(ac, (i + 1), av) == 1 && r == 0)
	my_printf("\n");
      i++;
    }
}
Example #21
0
int		check_map(char *str, t_infos *infos, t_list **rooms)
{
	if (check_ants(str, infos) == 1)
		return (1);
	else if (check_start(str, infos) == 1 && infos->ok != 2)
	 	return (1);
	else if (check_end(str, infos) == 1 && infos->ok != 2)
	 	return (1);
	else if(check_pos(str, rooms, infos) == 1)
		return (1);
	else if(check_tubes(str, infos, rooms) == 1)
	 	return (1);
	return (0);
}
Example #22
0
int			check_room(t_lem_env *env, char *s)
{
	if (is_link(s) && env->fonction[env->r.state + 1](env, s))
		return (ft_add_state(env));
	if (ft_strcmp("##start", s) == 0 && check_start(env, s))
		return (1);
	if (ft_strcmp("##end", s) == 0 && check_end(env, s))
		return (1);
	if (is_room(s) && add_room(env, s))
	{
		env->r.nbline += add_file(env, s);
		return (1);
	}
	return (ft_error(env, 1));
}
Example #23
0
int	step_two(int *remove_line, int *tab, int tab_size, char *buff)
{
  int	nbr;

  nbr = my_getnbr(buff);
  if (check_s2(buff, nbr, tab[*remove_line]) == 1)
    return (1);
  tab[*remove_line] = tab[*remove_line] - nbr;
  if (check_end(get_total_matches(tab, tab_size), 0) == -1)
    return (-1);
  show_tab(tab, tab_size);
  if (ia(tab, tab_size, 0) == -1)
    return (-1);
  *remove_line = -1;
  my_putstr("On which line would you want to remove matches ? ");
  return (0);
}
Example #24
0
    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
    {
        traits::clear<MultiGeometry>::apply(geometry);

        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
        tokenizer::iterator it;

        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it))
        {
            handle_open_parenthesis(it, tokens.end(), wkt);

            // If first point definition starts with "(" then parse points as (x y)
            // otherwise as "x y"
            bool using_brackets = (it != tokens.end() && *it == "(");
            
            while(it != tokens.end() && *it != ")")
            {
                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
                
                if (using_brackets)
                {
                    point_parser
                        <
                            typename boost::range_value<MultiGeometry>::type
                        >::apply(it, tokens.end(), wkt, *(boost::end(geometry) - 1));
                }
                else
                {
                    noparenthesis_point_parser
                        <
                            typename boost::range_value<MultiGeometry>::type
                        >::apply(it, tokens.end(), wkt, *(boost::end(geometry) - 1));
                }
                    
                if (it != tokens.end() && *it == ",")
                {
                    // Skip "," after point is parsed
                    ++it;
                }
            }
            
            handle_close_parenthesis(it, tokens.end(), wkt);
        }
        
        check_end(it, tokens.end(), wkt);
    }
Example #25
0
File: game.c Project: plean/CPE
void	ia_vs_ia(t_prog_base *base)
{
  int	i;

  while (42)
    {
      my_putstr("IA's turn...\n", 1);
      my_ia(base);
      aff_message(base, 2);
      if ((base->nb_deleted[base->line - 1] += base->matches) ==
	  base->matches_per_lines[base->line - 1])
	base->is_empty[base->line - 1] = 1;
      print_screen(base);
      check_end(base, 3);
      if (base->is_ended == 1)
	return ;
      i = 0;
      while (i++ < 100000000);
    }
}
Example #26
0
time_t
parse_time(char *time_str, int use_american_date_formats)
{
   struct tm    tm;
   char		**date_formats;

   memset(&tm, 0, sizeof (tm));
   tm.tm_isdst = -1;


   for (date_formats = (use_american_date_formats
			? american_date_formats
			: european_date_formats);
	*date_formats;
	date_formats++)
   {
       if (check_end((const char *)strptime(time_str, *date_formats, &tm)))
	   return mktime_from_utc(&tm);
   }

   return -1;
}
Example #27
0
time_t http_atotm(const char *time_string)
{
  /* NOTE: Solaris strptime man page claims that %n and %t match white
     space, but that's not universally available.  Instead, we simply
     use ` ' to mean "skip all WS", which works under all strptime
     implementations I've tested.  */

  static const char *time_formats[] =
  {
    "%a, %d %b %Y %T",  /* rfc1123: Thu, 29 Jan 1998 22:12:57 */
    "%A, %d-%b-%y %T",  /* rfc850:  Thursday, 29-Jan-98 22:12:57 */
    "%a %b %d %T %Y",  /* asctime: Thu Jan 29 22:12:57 1998 */
    "%a, %d-%b-%Y %T"  /* cookies: Thu, 29-Jan-1998 22:12:57 (used in Set-Cookie, defined in the Netscape cookie specification.) */
  };
  int i;

  for (i = 0; i < countof(time_formats); i++)
  {
    struct tm t;

    /* Some versions of strptime use the existing contents of struct
    tm to recalculate the date according to format.  Zero it out
    to prevent garbage from the stack influencing strptime.  */
    memset(&t,0,sizeof(t));

    /* Solaris strptime fails to recognize English month names in
    non-English locales, which we work around by not setting the
    LC_TIME category.  Another way would be to temporarily set
    locale to C before invoking strptime, but that's slow and
    messy.  GNU strptime does not have this problem because it
    recognizes English month names along with the local ones.  */

    if (check_end(strptime(time_string, time_formats[i], &t)))
      return timegm(&t);
  }

  /* All formats have failed.  */
  return -1;
}
Example #28
0
void			ft_epur_str(char *s)
{
	int i;

	i = 0;
	if (s[0] == '\0')
		return (ft_putchar('\n'));
	if (s)
		while (s[i])
		{
			while (ft_isspace(s[i]) != 0)
				i++;
			while (s[i] > 32 && s[i] < 127)
			{
				ft_putchar(s[i]);
				i++;
			}
			if (check_end(s, i) == 1)
				return (ft_putchar('\n'));
			else
				ft_putchar(' ');
		}
}
Example #29
0
File: server.c Project: kube/zappy
int					main(int ac, char **av)
{
	t_env				e;
	struct timeval		t;

	get_opt(ac, av, &e.opt);
	init_game(&e);
	init_connection(&e);
	while (1)
	{
		t.tv_sec = 0;
		t.tv_usec = 0;
		FD_ZERO(&e.fd_read);
		FD_ZERO(&e.fd_write);
		e.max = 0;
		fd_iter_all(&e, fd_watch);
		e.res = select(e.max + 1, &e.fd_read, &e.fd_write, NULL, &t);
		try_int(e.res, -1, "select");
		fd_iter_all(&e, fd_check);
		bot_iter_all_connected_queued_egg(&e, timer);
		check_end(&e);
	}
	return (EXIT_SUCCESS);
}
Example #30
0
void		game_start(char *board)
{
  int		i;
  char		killer;

  while (check_end(board) == 1)
    {
      i = 0;
      while (board[i] != '\0')
	{
	  if (board[i] == '1' || board[i] == '2')
	    {
	      if (board[i] == '1')
		killer = '2';
	      else
		killer = '1';
	      is_dead(board, i, killer);
	    }
	  ++i;
	}
      display_board(board);
      move_player(board);
    }
}