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");
}
int
main(int argc, const char *const argv[])
{
int exitcode;
check_args(argc, argv, 2);
if (strcmp(argv[1], "echo") == 0) {
check_args(argc, argv, 3);
exitcode = h_echo(argv[2]);
} else if (strcmp(argv[1], "exit-failure") == 0)
exitcode = h_exit_failure();
else if (strcmp(argv[1], "exit-signal") == 0)
exitcode = h_exit_signal();
else if (strcmp(argv[1], "exit-success") == 0)
exitcode = h_exit_success();
else if (strcmp(argv[1], "stdout-stderr") == 0) {
check_args(argc, argv, 3);
exitcode = h_stdout_stderr(argv[2]);
} else {
fprintf(stderr, "%s: Unknown helper %s\n", argv[0], argv[1]);
exitcode = EXIT_FAILURE;
}
return exitcode;
}
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);
}
int
mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
{
v_pre *p;
int line, pos;
char *tp;
switch (n->type) {
case (MDOC_TEXT):
tp = n->string;
line = n->line;
pos = n->pos;
check_text(mdoc, line, pos, tp);
/* FALLTHROUGH */
case (MDOC_TBL):
/* FALLTHROUGH */
case (MDOC_ROOT):
return(1);
default:
break;
}
check_args(mdoc, n);
if (NULL == mdoc_valids[n->tok].pre)
return(1);
for (p = mdoc_valids[n->tok].pre; *p; p++)
if ( ! (*p)(mdoc, n))
return(0);
return(1);
}
static int global_physics_test (lua_State *L)
{
TRY_START
LuaTestCallback lcb;
push_cfunction(L, my_lua_error_handler);
int error_handler = lua_gettop(L);
if (lua_gettop(L)==5) {
float radius = lua_tonumber(L, 1);
Vector3 pos = check_v3(L, 2);
bool only_dyn = check_bool(L, 3);
if (lua_type(L, 4) != LUA_TFUNCTION)
my_lua_error(L, "Parameter 4 should be a function.");
physics_test_sphere(radius, pos, only_dyn, lcb);
lcb.pushResults(L, 4, error_handler);
} else {
check_args(L, 6);
std::string col_mesh_name = check_path(L, 1);
DiskResource *col_mesh_ = disk_resource_get_or_make(col_mesh_name);
CollisionMesh *col_mesh = dynamic_cast<CollisionMesh*>(col_mesh_);
if (col_mesh==NULL) my_lua_error(L, "Not a collision mesh: \""+col_mesh_name+"\"");
if (!col_mesh->isLoaded()) my_lua_error(L, "Not loaded: \""+col_mesh_name+"\"");
Vector3 pos = check_v3(L, 2);
Quaternion quat = check_quat(L, 3);
bool only_dyn = check_bool(L, 4);
if (lua_type(L, 5) != LUA_TFUNCTION)
my_lua_error(L, "Parameter 5 should be a function.");
physics_test(col_mesh, pos, quat, only_dyn, lcb);
lcb.pushResults(L, 5, error_handler);
}
lua_pop(L, 1); // error handler
return 0;
TRY_END
}
kernel vmlinux --name test-option append kernel args
initrd initrd
#endif
/**
* Test that we recognise an ipxe-formatted script obtained from bootfile_url
* (DHCPv6 option 59) that some vendors use, and that we correctly parse the
* --name parameter from the kernel arguments.
*/
void run_test(struct parser_test *test)
{
struct discover_boot_option *opt;
struct discover_context *ctx;
test_read_conf_embedded_url(test, "tftp://host/dir1/conf");
test_set_event_source(test);
test_set_event_param(test->ctx->event, "bootfile_url", "tftp://host/dir1/conf");
test_run_parser(test, "pxe");
ctx = test->ctx;
check_boot_option_count(ctx, 1);
opt = get_boot_option(ctx, 0);
check_name(opt, "test-option");
check_resolved_url_resource(opt->boot_image,
"tftp://host/dir1/vmlinux");
check_resolved_url_resource(opt->initrd,
"tftp://host/dir1/initrd");
check_args(opt, "append kernel args");
}
int main(int argc, char *argv[])
{
int loop;
check_args(argc);
for (loop=0;loop<=19-1;loop++)
{
inData[loop] = 0;
}
unsigned short addlist[2] = {atoi(argv[1]), NOADDR}; // list to enable inst
//Reset Card 0 (i.e:gpib0)
SendIFC(0);
// ENABLE all on GPIB bus
EnableRemote(0, addlist);
// If error, Bye!
if (ibsta & ERR)
{
printf("Instrument enable failed!\n");
exit(1);
}
// Send (BoardID, GPIBAddr, Command, LengthCommand, Endline)
// typical command:
// Send(0, 20, "*RST", 4l, NLend);
Send(0, atoi(argv[1]), argv[2], strlen(argv[2]), NLend);
Receive(0, atoi(argv[1]), inData, 19, STOPend);
printf("%s",inData);
}
dtb ./pxe/de-ad-de-ad-be-ef.dtb
#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/dir/conf.txt");
test_set_event_source(test);
test_set_event_param(test->ctx->event, "pxeconffile",
"tftp://host/dir/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/dir/./pxe/de-ad-de-ad-be-ef.vmlinuz");
check_resolved_url_resource(opt->initrd,
"tftp://host/dir/./pxe/de-ad-de-ad-be-ef.initrd");
check_resolved_url_resource(opt->dtb,
"tftp://host/dir/./pxe/de-ad-de-ad-be-ef.dtb");
}
void
cmd_dump (int argc, char **argv)
{
mu_off_t off = 0;
size_t n;
mu_stream_t stream;
char buf[512];
int status;
if (check_args (argv[0], argc, 1, 2))
return;
if (argc == 2)
off = strtoul (argv[1], NULL, 0);
status = mu_header_get_stream (header, &stream);
if (status)
{
mu_error ("%u: cannot get stream: %s", line_num, mu_strerror (status));
return;
}
status = mu_stream_seek (stream, off, SEEK_SET);
if (status)
{
mu_error ("%u: cannot seek: %s", line_num, mu_strerror (status));
return;
}
while (mu_stream_sequential_read (stream, buf, sizeof buf, &n) == 0
&& n > 0)
{
fwrite (buf, 1, n, stdout);
}
}
void
cmd_write (int argc, char **argv)
{
char buf[512];
mu_stream_t str;
int status;
if (check_args (argv[0], argc, 1, 1))
return;
status = mu_header_get_stream (header, &str);
if (status)
{
mu_error ("%u: cannot get stream: %s", line_num, mu_strerror (status));
return;
}
printf("[reading headers; end with an empty line]\n");
mu_stream_seek (str, 0, SEEK_SET);
while (prompt (1), fgets(buf, sizeof buf, stdin))
{
mu_stream_sequential_write (str, buf, strlen (buf));
if (buf[0] == '\n')
break;
}
}
int main(int argc, char **argv)
{
int ts = 0, var = 0;
init_mpi(argc, argv);
parse_args(argc, argv);
check_args();
calculate_per_process_offsets();
create_synthetic_simulation_data();
rank_0_print("Simulation Data Created\n");
create_pidx_var_point_and_access();
for (ts = 0; ts < time_step_count; ts++)
{
set_pidx_file(ts);
for (var = 0; var < variable_count; var++)
set_pidx_variable(var);
PIDX_close(file);
}
destroy_pidx_var_point_and_access();
destroy_synthetic_simulation_data();
shutdown_mpi();
return 0;
}
static int stringdb_index(lua_State *L)
{
TRY_START
check_args(L,2);
GET_UD_MACRO(StringDB,self,1,STRINGDB_TAG);
if (lua_type(L,2)==LUA_TNUMBER) {
if (self.size()==0) {
my_lua_error(L,"Empty stringdb");
}
unsigned short index=check_t<unsigned short>(L,2,1,self.size());
lua_pushstring(L,self[index-1].c_str());
} else {
std::string key = luaL_checkstring(L,2);
if (key=="add") {
push_cfunction(L,stringdb_add);
} else if (key=="clear") {
push_cfunction(L,stringdb_clear);
} else if (key=="table") {
lua_createtable(L, self.size(), 0);
for (unsigned int i=0 ; i<self.size() ; i++) {
lua_pushnumber(L,i+1);
lua_pushstring(L,self[i].c_str());
lua_settable(L,-3);
}
} else {
my_lua_error(L,"Not a readable StringDB member: "+key);
}
}
return 1;
TRY_END
}
void pciconfread(int dmod, int offset, int count)
{
int err = 0;
short dbytes;
if(!diagdev) {
printf("Run pcidiagset first\n");
return;
}
if(check_args(dmod, offset, count))
return;
dbytes=dmod/8;
count/=dbytes;
if(count==0) count=1;
for(;count && !err;offset+=dbytes,count--) {
epicsUInt8 u8;
epicsUInt16 u16;
epicsUInt32 u32;
printf("0x%04x ", offset);
switch(dmod) {
case 8: err = devPCIConfigRead8(diagdev, offset, &u8); printf("%02x\n", u8); break;
case 16: err = devPCIConfigRead16(diagdev, offset, &u16); printf("%04x\n", u16); break;
case 32: err = devPCIConfigRead32(diagdev, offset, &u32); printf("%08x\n", u32); break;
default:
printf("Invalid dmod %d, must be 8, 16, or 32\n", dmod);
break;
}
}
if(err)
printf("read error %d\n", err);
}
void pciread(int dmod, int offset, int count)
{
epicsUInt32 tval;
volatile char* dptr;
short dbytes;
int i;
if(!diagbase) {
printf("Run pcidiagset first\n");
return;
}
if(check_args(dmod, offset, count))
return;
dbytes=dmod/8;
count/=dbytes;
if(count==0) count=1;
for(i=0, dptr=diagbase+offset; i<count; i++, dptr+=dbytes) {
if ((i*dbytes)%16==0)
printf("\n0x%08x ",i*dbytes);
else if ((i*dbytes)%4==0)
printf(" ");
switch(dmod){
case 8: tval=ioread8(dptr); printf("%02x",tval);break;
case 16: tval=nat_ioread16(dptr);printf("%04x",tval);break;
case 32: tval=nat_ioread32(dptr);printf("%08x",tval);break;
}
}
printf("\n");
}
void
cmd_free (int argc, char **argv)
{
if (check_args (argv[0], argc, 1, 1))
return;
mu_iterator_destroy (&iterator);
mu_header_destroy (&header, NULL);
}
void
cmd_load (int argc, char **argv)
{
if (check_args (argv[0], argc, 2, 2))
return;
mu_header_destroy (&header, NULL);
load_file (argv[1]);
}
static int global_physics_option_reset (lua_State *L)
{
TRY_START
check_args(L, 0);
physics_option_reset();
return 0;
TRY_END
}
