C++ check_args函数代码示例

initrd /boot/initrd

#endif

void run_test(struct parser_test *test)
{
	struct discover_boot_option *opt;
	struct discover_context *ctx;

	test_read_conf_embedded(test, "/boot/petitboot.conf");

	test_run_parser(test, "native");

	ctx = test->ctx;

	check_boot_option_count(ctx, 2);

	opt = get_boot_option(ctx, 0);

	check_name(opt, "first");
	check_resolved_local_resource(opt->boot_image, ctx->device, "/vmlinuz");
	check_args(opt, "console=hvc0");
	check_resolved_local_resource(opt->initrd, ctx->device, "/initrd");
	check_is_default(opt);

	opt = get_boot_option(ctx, 1);
	check_name(opt, "second");
	check_resolved_local_resource(opt->boot_image, ctx->device, "/boot/vmlinuz");
	check_args(opt, "console=tty0");
	check_resolved_local_resource(opt->initrd, ctx->device, "/boot/initrd");
}

bool ZorbaCMDProperties::loadProperties(int argc, char* argv[]) 
{
  std::string result = load_argv(argc, (const char **) argv);

  if (result.empty())
    result = check_args();

  if (result == "!HELP") 
  {
    std::cout << "Zorba XQuery Engine, Version: " 
              << zorba::Zorba::version() << std::endl;
    std::cout << "Available options:\n\n";
    std::cout << get_help_msg ();
    return false;
  }
  else if (result == "!VER") 
  {
    std::cout << "Zorba XQuery Engine, Version: " 
              << zorba::Zorba::version() << std::endl;
    return false;
  }
  else if (result.empty ())
  {
    return true;
  }
  else if (result [0] != '!')
  {
    std::cout << "Error: " << result << std::endl;
    return false;
  }
  else
  {
    return false;
  }  
}

int			main(int ac, char **av)
{
	pid_t	pid;
	int		i;
	long	tab_set[MAX_FRACTALS];
	int		nbr_frac;

	i = 0;
	ft_memset(tab_set, 0, MAX_FRACTALS);
	(ac == 2 && !ft_strcmp("-all", av[1]) ? show_them_all(tab_set, &nbr_frac) :
	check_args(ac, av, tab_set, &nbr_frac));
	while (i < nbr_frac)
	{
		pid = fork();
		if (pid == -1)
		{
			perror("Error forking");
			return (EXIT_FAILURE);
		}
		if (pid == 0)
			start_fractal((void *)tab_set[i]);
		i++;
	}
	if (pid > 0)
		waitpid(-1, NULL, 0);
	return (EXIT_SUCCESS);
}

/**
 * Main function
 * checks commandline args with check_args, then calls detect()
 */
int main(int argc, char* argv[])
{
    /* Check ARGs */
    if(check_args(argc, argv) != EXIT_SUCCESS)
        return EXIT_FAILURE;
    return detect();
}

int	op_add(t_action *action, char *str, t_pos *pos)
{
  int	i;
  char	c;
  char	type;
  char	**tab;
  char	**list_arg;

  if ((c = 0) || !(pos->prog_size += 2) ||
      !(i = -1) || !(action->identifier = 0x04) ||
      !(action->args = malloc(sizeof(t_arg *) * 4)) ||
      !(tab = str_to_word_tab(str, ',')) ||
      !(list_arg = str_to_word_tab("1 1 1", ' ')) ||
      init_args(action, 3))
    return (1);
  while (tab[++i])
    {
      if (i > 2 || (type = check_type(tab[i], pos)) == -1 ||
	  check_args(type, list_arg[i], pos) ||
	  fill_arg(type, tab[i], action->args[i], action->pos - i - 1))
	return (1);
      add_prog_size(type, pos);
      c += (type << (6 - (i * 2)));
    }
  action->coding_byte = c;
  return (free_tab(tab), free_tab(list_arg), (i < 3) ? 1 : 0);
}

int check_args_enc(type_image *img) {
	if (strstr(img->in_file, ".bsq") != NULL)
		img->bsq_file = 1;
	if (strstr(img->in_file, ".bip") != NULL)
		img->bip_file = 1;
	if (strstr(img->in_file, ".bil") != NULL)
		img->bil_file = 1;

	if (img->in_hfile != NULL) {
		if (strstr(img->in_hfile, ".hdr") == NULL) {
			fprintf(stderr, "Wrong header file: %s! (Should be *.hdr)\n", img->in_hfile);
			return ERROR;
		} else {
			if ((strstr(img->in_file, ".bsq") == NULL) && (strstr(img->in_file, ".bip") == NULL) && (strstr(
					img->in_file, ".bil") == NULL)) {
				fprintf(stderr, "Wrong image file: %s! (Should be one of following: *.bsq, *.bip, *.bil)\n",
						img->in_file);
				return ERROR;
			}
		}
	} else {
		if (strstr(img->out_file, ".j2k") == NULL) {
			fprintf(stderr, "Wrong extension: %s (Should be *.j2k)\n", img->out_file);
			return ERROR;
		}
	}

	return check_args(img);
}

static int rbody_ranged_scatter (lua_State *L)
{
TRY_START
        check_args(L, 12);
        GET_UD_MACRO(RigidBody, self, 1, RBODY_TAG);
        std::string mat    = check_path(L, 2);
        GET_UD_MACRO(GfxRangedInstancesPtr, gri, 3, GFXRANGEDINSTANCES_TAG);
        float density       = check_float(L, 4);
        float min_slope     = check_float(L, 5);
        float max_slope     = check_float(L, 6);
        float min_elevation = check_float(L, 7);
        float max_elevation = check_float(L, 8);
        bool no_z           = check_bool(L, 9);
        bool rotate         = check_bool(L, 10);
        bool align_slope    = check_bool(L, 11);
        unsigned seed       = check_t<unsigned>(L, 12);

        SimpleTransform world_trans(self.getPosition(), self.getOrientation());

        self.colMesh->scatter(phys_mats.getMaterial(mat)->id,
                              world_trans, density, min_slope, max_slope, min_elevation,
                              max_elevation, no_z, rotate, align_slope, seed,
                              *gri);

        return 0;
TRY_END
}

static void
ybinomial(void)
{
	K = pop();
	N = pop();

	if (check_args() == 0) {
		push(zero);
		return;
	}

	push(N);
	factorial();

	push(K);
	factorial();

	divide();

	push(N);
	push(K);
	subtract();
	factorial();

	divide();
}

int python_exec_string(void)
{
    if( !python_is_initialised_check() )
        return 0;

    EmacsString command;

    if( cur_exec == NULL )
    {
        EmacsString prompt( ": Python-exec " );

        command = get_string_interactive( prompt );
    }
    else
    {
        if( check_args( 1, 1 ) )
            return 0;

        command = get_string_mlisp();
    }

    EmacsPythonExecCommand py_command( command );

    py_command.executeCommand();

    if( py_command.failed() )
        error( py_command.failureReason() );
    else
        ml_value = py_command.getResult();

    return 0;
}

initrd /initrd
#endif

void run_test(struct parser_test *test)
{
	struct discover_boot_option *opt;
	struct discover_context *ctx;

	test_read_conf_embedded_url(test, "tftp://host/path/to/conf.txt");

	test_set_event_source(test);
	test_set_event_param(test->ctx->event, "pxepathprefix",
			"tftp://host/path/to/");
	test_set_event_param(test->ctx->event, "pxeconffile", "conf.txt");

	test_run_parser(test, "pxe");

	ctx = test->ctx;

	check_boot_option_count(ctx, 1);
	opt = get_boot_option(ctx, 0);

	check_name(opt, "linux");
	check_args(opt, "command line");

	check_resolved_url_resource(opt->boot_image,
			"tftp://host/path/to/./kernel");
	check_resolved_url_resource(opt->initrd,
			"tftp://host/path/to/initrd");
}

static VALUE strongtyping_overload(int argc, VALUE *argv, VALUE self UNUSED) {
  struct RArray *q;
    
  if(argc < 1)
    rb_raise(rb_eArgError, "At least one parameter required");

  Check_Type(argv[0], T_ARRAY);
  q = RARRAY(argv[0]);

  if(RARRAY_LEN(q) && rb_funcall(RARRAY_PTR(q)[0], id_isa, 1, cQueryParams)) {
    rb_funcall(RARRAY_PTR(q)[0], rb_intern("<<"), 1, rb_ary_new4(argc - 1, argv + 1));
    return Qnil;
  }

  if(RARRAY_LEN(q) != (argc - 1))
    return Qnil;

  if(check_args(argc - 1, RARRAY_PTR(q), argv + 1) < 0){
    if(argc == 2)
      rb_yield(*RARRAY_PTR(*argv));
    else
      rb_yield(*argv);
  }

  return Qnil;
}

int main(int argc, char** argv) {
    nabto_main_setup* nms = unabto_init_context();

    stream_echo_init();
    
    if (!check_args(argc, argv, nms)) {
        return 1;
    }

    if (!unabto_init()) {
        return 1;
    }
    
    while(true) {
        unabto_tick();
#ifdef WIN32
        Sleep(1);
#endif
#if (_POSIX_C_SOURCE >= 199309L)
        struct timespec sleepTime;
        sleepTime.tv_sec = 0;
        sleepTime.tv_nsec = 10*1000000;
        nanosleep(&sleepTime, NULL);
#endif
    }
    
    unabto_close();
}

int		main(int ac, char **av)
{
  t_args	option;

  if (ac < 5)
    return (usage(av[0]));
  signal(SIGINT, &signal_handler);
  signal(SIGPIPE, SIG_IGN);
  srand(time(NULL) + getpid());
  init_args(&option);
  if (check_args(ac, av, &option) == false
      || check_all_args(&option) == false)
    return (usage(av[0]));
  display_init(&option);
  g_s.global_time = 0;
  g_s.id_egg = 1;
  g_s.other_size = 0;
  if ((g_s.sock = init_server(option.port)) == -1)
    return (display_error("Error : Could not init the server.\n"));
  printf("**** Initialization done\n");
  init_map(&g_s, option.width, option.height);
  init_team(&g_s, option.nb_client, option.team_name);
  init_stone(&g_s, option.width * option.height);
  g_s.option = &option;
  server_loop(&g_s);
  xclose(g_s.sock);
  return (0);
}

static int global_current_dir (lua_State *L)
{
    check_args(L, 0);
    std::string dir = lua_current_dir(L);
    push_string(L, dir);
    return 1;
}

int				check_size(char *line, char *col, t_gboard *board)
{
	int		check_int;

	if ((check_int = check_args(line, col)) == -1)
	{
		ft_puterr(P4_ERROR);
		ft_puterr(P4_COORDS);
		ft_puterr("\n");
		return (-1);
	}
	else
	{
		board->nb_columns = ft_atoi(col);
		board->nb_lines = ft_atoi(line);
		if (board->nb_lines < 6 || board->nb_columns < 7)
		{
			ft_puterr(P4_ERROR);
			ft_puterr(P4_SIZE);
			ft_puterr("\n");
			return (-1);
		}
	}
	return (0);
}