int
main( int argc, char **argval )
{
JOB_DATA job_data;
long long cnt = 0;
signal( SIGINT, sig_int_handler );
#ifndef _HAVE_MSG_NOSIGNAL_
signal( SIGPIPE, SIG_IGN );
#endif
parse_cmd_line( argc, argval, &job_data );
create_payload( &job_data );
if ( job_data.verbose ) {
print_job_data( job_data );
} /* if */
cnt = flood_forked( job_data );
//printf( "%s[%d]: Sent %lld packets.\n\n", APPNAME, (int)getpid(), cnt );
free_job_data( &job_data );
drop_hash();
return cnt > 0;
} /* main */
int main(int argc, char *argv[]) {
int ret;
config.logFilePath = DEFAULT_LOG_FILE_PATH;
config.logLevel = INFO_LOG;
parse_cmd_line(argc, argv);
ret = load_config();
if(ret) {
log_message(ERROR_LOG, "Loading configuration failed.");
config_free();
return 1;
}
ret = initialize();
if(ret != 0) {
log_message(ERROR_LOG, "initialize is failed.");
config_free();
return 1;
}
ret = socks_proxy();
cachemgr_fini();
log_fini();
config_free();
return 0;
}
int main(int argc, char* argv[])
{
char* cmd = NULL;
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
int socket_fd;
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGINT, sign_handler);
signal(SIGTERM, sign_handler);
if((socket_fd = parse_cmd_line(argc, argv, mem_pool)) <= 0)
{
mem_pool_destroy(mem_pool);
return 0;
}
while (global_start) {
if ((cmd = readline("MILE>")) == NULL) {
break;
}
parse_cmd(cmd,socket_fd,mem_pool);
mem_pool_reset(mem_pool);
if(cmd != NULL)
{
free(cmd);
cmd = NULL;
}
}
mem_pool_destroy(mem_pool);
return 0;
}
static void spawn_init_start(int8_t *cmd_line)
{
proc_t *init_proc = proc_make(noval); // group leader set later
assert(init_proc != 0);
init_proc->cap.regs[0] = parse_cmd_line(&init_proc->hp, cmd_line);
assert(init_proc->cap.regs[0] != noval);
init_proc->cap.live = 1;
init_proc->init_call_mod = A_INIT;
init_proc->init_call_func = A_BOOT;
init_proc->init_call_arity = 1;
export_t *exp = code_base_lookup(A_INIT, A_BOOT, 1);
assert(exp != 0);
init_proc->cap.ip = exp->entry;
module_info_t *mi = code_base_module_by_name(A_INIT, 0);
assert(mi != 0);
init_proc->cap.cp = mi->code_starts + mi->code_size-1;
scheduler_enlist0(init_proc); // pid assigned
init_proc->group_leader = init_proc->pid; // init is its own leader
proc_main(init_proc);
/* UNREACHANBLE */
}
int main(int argc, char *argv[])
{
MLOG_init( MLOG_LEVEL_INFO, MLOG_ACTION_CONSOLE, 0);
parse_cmd_line( argc, argv );
start_server();
return 0;
}
int main(int argc, char** argv)
{
options opts = parse_cmd_line(argc,argv);
if(opts.do_help)
{
if(opts.error)
{
std::cout << "Error parsing the command line." << std::endl;
}
do_help(argv);
return -1;
}
if(test_duplicate_list(opts.node_count,opts.use_quick_and_dirty))
{
std::cout << "Contratulations. duplicate_list is a success." << std::endl;
}
else
{
std::cout << "Unfortunately, duplicate_list failed." << std::endl;
}
return 0;
}
void
run_menu_command(GtkWidget *menu, MenuItem *mi) {
(void) menu;
if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
gchar* cmd = g_strdup_printf("%s %s", mi->cmd, mi->argument);
parse_cmd_line(cmd, NULL);
g_free(cmd);
g_free(mi->argument);
}
else {
parse_cmd_line(mi->cmd, NULL);
}
}
/**
* 程序入口
*/
int main(int argc, char** argv) {
cmdline_param cp;
easy_listen_t* listen;
easy_io_handler_pt io_handler;
int ret;
// default
memset(&cp, 0, sizeof(cmdline_param));
cp.io_thread_cnt = 1;
// parse cmd line
if (parse_cmd_line(argc, argv, &cp) == EASY_ERROR)
return EASY_ERROR;
// 检查必需参数
if (cp.port == 0) {
print_usage(argv[0]);
return EASY_ERROR;
}
// 对easy_io初始化, 设置io的线程数, file的线程数
if (!easy_io_create(cp.io_thread_cnt)) {
easy_error_log("easy_io_init error.\n");
return EASY_ERROR;
}
// 为监听端口设置处理函数，并增加一个监听端口
easy_io_var.tcp_defer_accept = 0;
memset(&io_handler, 0, sizeof(io_handler));
io_handler.decode = echo_decode;
io_handler.encode = echo_encode;
io_handler.process = echo_process;
io_handler.on_connect = echo_connect;
if ((listen = easy_io_add_listen(NULL, cp.port, &io_handler)) == NULL) {
easy_error_log("easy_io_add_listen error, port: %d, %s\n",
cp.port, strerror(errno));
return EASY_ERROR;
} else {
easy_error_log("listen start, port = %d\n", cp.port);
}
// 起处理速度统计定时器
ev_timer stat_watcher;
easy_io_stat_t iostat;
easy_io_stat_watcher_start(&stat_watcher, 5.0, &iostat, NULL);
// 起线程并开始
if (easy_io_start()) {
easy_error_log("easy_io_start error.\n");
return EASY_ERROR;
}
// 等待线程退出
ret = easy_io_wait();
easy_io_destroy();
return ret;
}
int
main (int argc, char **argv)
{
#ifdef ANDROID
read_default_bdaddr();
#endif
if (parse_cmd_line(argc, argv)) {
exit(1);
}
if (uart_fd < 0) {
exit(2);
}
init_uart();
proc_reset();
if (use_baudrate_for_download) {
if (termios_baudrate) {
proc_baudrate();
}
}
if (hcdfile_fd > 0) {
proc_patchram();
}
if (termios_baudrate) {
proc_baudrate();
}
if (bdaddr_flag) {
proc_bdaddr();
}
if (enable_lpm) {
proc_enable_lpm();
}
if (scopcm) {
proc_scopcm();
}
if (i2s) {
proc_i2s();
}
if (enable_hci) {
proc_enable_hci();
while (1) {
sleep(UINT_MAX);
}
}
exit(0);
}
int main(int argc, char * argv[])
{
int dh_bits=2048;
if (argc<2) {
usage();
return 1 ;
}
OpenSSL_add_all_algorithms();
/* Initialize DN fields to default values */
memset(&certinfo, 0, sizeof(certinfo));
certinfo.rsa_keysz = RSA_KEYSZ ;
strcpy(certinfo.o, "Home");
certinfo.days = 3650 ;
strcpy(certinfo.signing_ca, "root");
if ((argc>2) && (parse_cmd_line(argc, argv)!=0)) {
return -1 ;
}
if (certinfo.cn[0]==0) {
strcpy(certinfo.cn, argv[1]);
}
if (!strcmp(argv[1], "root")) {
certinfo.profile = PROFILE_ROOT_CA ;
build_identity();
} else if (!strcmp(argv[1], "sub")) {
certinfo.profile = PROFILE_SUB_CA ;
build_identity();
} else if (!strcmp(argv[1], "server")) {
certinfo.profile = PROFILE_SERVER ;
build_identity() ;
} else if (!strcmp(argv[1], "client")) {
certinfo.profile = PROFILE_CLIENT ;
build_identity() ;
} else if (!strcmp(argv[1], "www")) {
certinfo.profile = PROFILE_WWW ;
build_identity() ;
} else if (!strcmp(argv[1], "crl")) {
show_crl(certinfo.signing_ca);
} else if (!strcmp(argv[1], "revoke")) {
if (argc>2) {
revoke_cert(certinfo.signing_ca, argv[2]);
} else {
fprintf(stderr, "Missing certificate name for revocation\n");
}
} else if (!strcmp(argv[1], "dh")) {
if (argc>2) {
dh_bits=atoi(argv[2]);
}
generate_dhparam(dh_bits);
}
return 0 ;
}
int main(int argc,char *argv[]){
int exitcode = 0;
t_state state, *s=&state;
/* Parse command line and pass any relevant arguments to CPU record */
parse_cmd_line(argc,argv, &cmd_line_args);
fprintf(stderr,"ION (MIPS32 clone) core emulator (" __DATE__ ")\n\n");
if(!init_cpu(s, &cmd_line_args)){
fprintf(stderr,"Trouble allocating memory, quitting!\n");
exit(71);
};
/* Read binary object files into memory*/
if(!read_binary_files(s, &cmd_line_args)){
exit(66);
}
fprintf(stderr,"\n\n");
/* Open the CPU console output file if not stdout. */
if (cmd_line_args.conout_filename!=NULL) {
cpuconout = fopen(cmd_line_args.conout_filename, "w");
if (cpuconout==NULL){
fprintf(stderr,"Trouble opening console log file '%s', quitting.\n", cmd_line_args.conout_filename);
exitcode = 2;
goto main_quit;
}
}
else {
cpuconout = stdout;
}
init_trace_buffer(s, &cmd_line_args);
/* NOTE: Original mlite supported loading little-endian code, which this
program doesn't. The endianess-conversion code has been removed.
*/
/* Simulate a CPU reset */
reset_cpu(s);
/* Simulate the work of the uClinux bootloader */
if(cmd_line_args.memory_map == MAP_UCLINUX){
/* FIXME this 'bootloader' is a stub, flesh it out */
s->pc = 0x80002400;
}
/* Enter debug command interface; will only exit clean with user command */
do_debug(s, cmd_line_args.no_prompt);
main_quit:
/* Close and deallocate everything and quit */
close_trace_buffer(s);
free_cpu(s);
if (cmd_line_args.conout_filename!=NULL && cpuconout!=NULL) fclose(cpuconout);
exit(0);
}
void
test_sync_sh (void) {
GString *result = g_string_new("");
parse_cmd_line("sync_sh 'echo Test echo.'", result);
g_assert_cmpstr("Test echo.\n", ==, result->str);
g_string_free(result, TRUE);
}
void
run_menu_command(GtkWidget *menu, MenuItem *mi) {
(void) menu;
if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
gchar* uri;
g_object_get(mi->hittest, "image-uri", &uri, NULL);
gchar* cmd = g_strdup_printf("%s %s", mi->cmd, uri);
parse_cmd_line(cmd, NULL);
g_free(cmd);
g_free(uri);
g_object_unref(mi->hittest);
}
else {
parse_cmd_line(mi->cmd, NULL);
}
}
int main(void)
{
char *argv[MAX_ARGC];
int argc;
char line[400];
SIOUXSettings.asktosaveonclose = 0;
SIOUXSettings.showstatusline = 1;
argc=parse_cmd_line(MAX_ARGC,argv,sizeof(line),line);
return xxx_main(argc,argv);
}
void
test_event (struct EventFixture *ef, const void *data) {
(void) data;
parse_cmd_line("event", NULL);
assert_no_event(ef);
/* a simple event can be sent */
parse_cmd_line("event event_type arg u ments", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE arg u ments");
/* arguments to event should be expanded */
parse_cmd_line("event event_type @(echo expansion)@ test", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE expansion test");
/* "request" is just an alias for "event" */
parse_cmd_line("request event_type arg u ments", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE arg u ments");
}
void
test_js (void) {
GString *result = g_string_new("");
/* simple javascript can be evaluated and returned */
parse_cmd_line("js ('x' + 345).toUpperCase()", result);
g_assert_cmpstr("X345", ==, result->str);
g_string_free(result, TRUE);
}
void
test_scroll (void) {
GtkScrollbar *scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL);
uzbl.gui.bar_v = gtk_range_get_adjustment((GtkRange*) scbar_v);
gtk_adjustment_set_lower(uzbl.gui.bar_v, 0);
gtk_adjustment_set_upper(uzbl.gui.bar_v, 100);
gtk_adjustment_set_page_size(uzbl.gui.bar_v, 5);
/* scroll vertical end should scroll it to upper - page_size */
parse_cmd_line("scroll vertical end", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 95);
/* scroll vertical begin should scroll it to lower */
parse_cmd_line("scroll vertical begin", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 0);
/* scroll vertical can scroll by pixels */
parse_cmd_line("scroll vertical 15", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 15);
parse_cmd_line("scroll vertical -10", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 5);
/* scroll vertical can scroll by a percentage of the page size */
parse_cmd_line("scroll vertical 100%", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 10);
parse_cmd_line("scroll vertical 150%", NULL);
g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 17.5);
/* scroll_horz behaves basically the same way. */
}
gboolean
control_client_socket(GIOChannel *clientchan) {
char *ctl_line;
GString *result = g_string_new("");
GError *error = NULL;
GIOStatus ret;
gsize len;
ret = g_io_channel_read_line(clientchan, &ctl_line, &len, NULL, &error);
if (ret == G_IO_STATUS_ERROR) {
g_warning ("Error reading: %s", error->message);
g_clear_error (&error);
ret = g_io_channel_shutdown (clientchan, TRUE, &error);
remove_socket_from_array (clientchan);
if (ret == G_IO_STATUS_ERROR) {
g_warning ("Error closing: %s", error->message);
g_clear_error (&error);
}
return FALSE;
} else if (ret == G_IO_STATUS_EOF) {
/* shutdown and remove channel watch from main loop */
ret = g_io_channel_shutdown (clientchan, TRUE, &error);
remove_socket_from_array (clientchan);
if (ret == G_IO_STATUS_ERROR) {
g_warning ("Error closing: %s", error->message);
g_clear_error (&error);
}
return FALSE;
}
if (ctl_line) {
parse_cmd_line (ctl_line, result);
g_string_append_c(result, '\n');
ret = g_io_channel_write_chars (clientchan, result->str, result->len,
&len, &error);
if (ret == G_IO_STATUS_ERROR) {
g_warning ("Error writing: %s", error->message);
g_clear_error (&error);
}
if (g_io_channel_flush(clientchan, &error) == G_IO_STATUS_ERROR) {
g_warning ("Error flushing: %s", error->message);
g_clear_error (&error);
}
}
g_string_free(result, TRUE);
g_free(ctl_line);
return TRUE;
}
void gendep(const deque<wstring>& params) {
list<wstring> source_dirs, include_dirs;
parse_cmd_line(params, source_dirs, include_dirs);
wstring output;
set<wstring> file_set;
for (list<wstring>::const_iterator src_dir = source_dirs.begin(); src_dir != source_dirs.end(); src_dir++) {
DirList dir_list(get_full_path_name(src_dir->empty() ? L"." : *src_dir));
while (dir_list.next()) {
if (!dir_list.data().is_dir() && is_valid_ext(dir_list.data().cFileName)) {
process_file(output, file_set, add_trailing_slash(*src_dir) + dir_list.data().cFileName, include_dirs);
}
}
}
cout << unicode_to_ansi(output, CP_ACP);
}
void
test_set_variable (struct EventFixture *ef, const void *data) {
(void) data;
/* set a string */
parse_cmd_line("set useragent = Uzbl browser kthxbye!", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET useragent str 'Uzbl browser kthxbye!'");
g_assert_cmpstr("Uzbl browser kthxbye!", ==, uzbl.net.useragent);
/* set an int */
parse_cmd_line("set forward_keys = 0", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET forward_keys int 0");
g_assert_cmpint(0, ==, uzbl.behave.forward_keys);
/* set a float */
/* we have to be careful about locales here */
GString *cmd;
cmd = g_string_new("set zoom_level = ");
g_string_append_printf(cmd, "%f", 0.25);
parse_cmd_line(g_string_free(cmd, FALSE), NULL);
ASSERT_EVENT(ef, "VARIABLE_SET zoom_level float 0.25");
g_assert_cmpfloat(0.25, ==, get_var_value_float("zoom_level"));
/* set a constant int (nothing should happen) */
int old_major = uzbl.info.webkit_major;
parse_cmd_line("set WEBKIT_MAJOR = 100", NULL);
assert_no_event(ef);
g_assert_cmpint(old_major, ==, uzbl.info.webkit_major);
/* set a constant str (nothing should happen) */
GString *old_arch = g_string_new(uzbl.info.arch);
parse_cmd_line("set ARCH_UZBL = A Lisp Machine", NULL);
assert_no_event(ef);
g_assert_cmpstr(g_string_free(old_arch, FALSE), ==, uzbl.info.arch);
/* set a custom variable */
parse_cmd_line("set nonexistant_variable = Some Value", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET nonexistant_variable str 'Some Value'");
uzbl_cmdprop *c = g_hash_table_lookup(uzbl.behave.proto_var, "nonexistant_variable");
g_assert_cmpstr("Some Value", ==, *(c->ptr.s));
/* set a custom variable with expansion */
parse_cmd_line("set an_expanded_variable = Test @(echo expansion)@", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET an_expanded_variable str 'Test expansion'");
c = g_hash_table_lookup(uzbl.behave.proto_var, "an_expanded_variable");
g_assert_cmpstr("Test expansion", ==, *(c->ptr.s));
}
int main(int argc, char** argv)
{
int ret = EXIT_SUCCESS;
mysql_init(NULL);
parse_cmd_line(argc, argv);
TBSYS_CONFIG.load(g_config);
TBSYS_LOGGER.setFileName("bigquery.log");
TBSYS_LOGGER.setLogLevel("info");
TBSYS_LOGGER.setMaxFileSize(256 * 1024L * 1024L); /* 256M */
BigqueryTest bigquery;
bigquery.start();
bigquery.wait();
bigquery.stop();
return ret;
}
int main(int argc, char **argv)
{
parse_cmd_line(argc, argv);
FileList *filelist = (FileList *)malloc(sizeof(FileList));
FileList_Init(filelist);
GetFileListInPaths(DIRPATHS, filelist);
IdentFileList *ifiles;
IdenticalFile_Init(&ifiles);
GetIdenticalFile(filelist, ifiles);
if (OPTIONS & OPT_HASH)
PrintIdenticalFileHash(ifiles);
else
PrintIdenticalFile(ifiles);
}
int main(int argc, char **argv)
{
MastSendTool *tool = NULL;
SF_INFO sfinfo;
// Create the send tool object
tool = new MastSendTool( MAST_TOOL_NAME );
tool->enable_scheduling();
// Parse the command line arguments
// and configure the session
parse_cmd_line( argc, argv, tool );
// Open the input file by filename
memset( &sfinfo, 0, sizeof(sfinfo) );
g_input_file = sf_open(g_filename, SFM_READ, &sfinfo);
if (g_input_file == NULL) MAST_FATAL("Failed to open input file:\n%s", sf_strerror(NULL));
tool->set_input_channels( sfinfo.channels );
tool->set_input_samplerate( sfinfo.samplerate );
// Display some information about the input file
print_file_info( g_input_file, &sfinfo );
// Setup signal handlers
mast_setup_signals();
// Run the main loop
tool->run();
// Clean up
delete tool;
// Close input file
if (sf_close( g_input_file )) {
MAST_ERROR("Failed to close input file:\n%s", sf_strerror(g_input_file));
}
// Success !
return 0;
}
gboolean
control_stdin(GIOChannel *gio, GIOCondition condition) {
(void) condition;
gchar *ctl_line = NULL;
GIOStatus ret;
ret = g_io_channel_read_line(gio, &ctl_line, NULL, NULL, NULL);
if ( (ret == G_IO_STATUS_ERROR) || (ret == G_IO_STATUS_EOF) )
return FALSE;
GString *result = g_string_new("");
parse_cmd_line(ctl_line, result);
g_free(ctl_line);
puts(result->str);
g_string_free(result, TRUE);
return TRUE;
}
// Main driver for program1
int main(int argc, char** argv)
{
options opts = parse_cmd_line(argc, argv);
if(opts.do_help)
{
if(opts.error)
{
std::cout << "Error parsing command line." << std::endl;
}
do_help(argv);
return -1;
}
if(opts.run_tests)
{
std::ifstream file;
file.open(opts.input_file,std::ifstream::out);
test_reverse_word(file);
file.close();
return 0;
}
char* sentence = &opts.sentence[0];
std::cout << "Input sentence: " << opts.sentence << std::endl;
if(opts.use_quick_and_dirty)
{
reverse_words_quick_and_dirty(sentence);
}
else
{
reverse_words(sentence);
}
std::cout << "Output sentence: " << sentence << std::endl;
return 0;
}
int main(int argc, char **argv)
{
MastSendTool *tool = NULL;
jack_client_t* client = NULL;
// Create the send tool object
tool = new MastSendTool( MAST_TOOL_NAME );
// Parse the command line arguments
// and configure the session
parse_cmd_line( argc, argv, tool );
// Initialise Jack
client = init_jack( tool );
if (client==NULL) MAST_FATAL( "Failed to initialise JACK client" );
// Get the samplerate of the JACK Router
tool->set_input_samplerate( jack_get_sample_rate( client ) );
// Setup signal handlers
mast_setup_signals();
// Run the main loop
tool->run();
// Clean up
delete tool;
// Shut down JACK
deinit_jack( client );
// Success !
return 0;
}
int main(int argc, char* argv[])
{
init_default_config();
parse_cmd_line(argc, argv);
init_thread_event_loops(g_config.thread_number);
init_thread_base_conn(g_config.thread_number);
for (int i = 0; i < g_config.thread_number; ++i) {
NbClientConn* client = new NbClientConn();
net_handle_t handle = client->Connect(g_config.host, g_config.port);
if (handle != NETLIB_INVALID_HANDLE) {
PktHeartBeat* pkt = new PktHeartBeat;
BaseConn::SendPkt(handle, pkt);
}
}
get_main_event_loop()->Start();
return 0;
}
/**
* No need to explain this.
*
* @param argc Number of arguments.
* @param argv Arguments array.
* @return Return code.
*/
int main(int argc, char **argv) {
bool running = true;
char *script_file = NULL;
char *csv_file = NULL;
char *ctok = NULL;
gnuplot_ctrl *gp = gnuplot_init();
char prompt[64] = "> ";
if (argc == 2) {
if (argv[1][strlen(argv[1]) - 3] == '.' &&
argv[1][strlen(argv[1]) - 2] == 'p' &&
argv[1][strlen(argv[1]) - 1] == 'c') {
// Script file.
script_file = argv[1];
running = parse_script(script_file, ctok, &csv_file, gp, prompt);
} else {
// CSV file.
csv_file = argv[1];
generate_prompt(prompt, csv_file);
}
}
while (running) {
char *buffer = NULL;
buffer = readline(prompt);
if (buffer && *buffer) {
add_history(buffer);
ctok = strtok(buffer, " ");
} else {
continue;
}
running = parse_cmd_line(ctok, &csv_file, gp, prompt, false);
}
gnuplot_close(gp);
return EXIT_SUCCESS;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int main(int argc, char **argv) /* @7c */
{
int i;
int rc; /* @7a */
rc = parse_cmd_line(argc, argv, cmds, &num_subcmds); /* @7a */
if (rc != BAIL_OUT) /* @7c */
if (open_files(cmds, argc, argv) != BAIL_OUT)
if (num_files)
{
for (i = firstfile; i < argc; i++)
if (process_file_spec(argv[i], cmds) == BAIL_OUT)
{ /* @7a */
rc = BAIL_OUT; /* @7a */
break;
} /* @7a */
}
else
rc = process_file(NULL, cmds); /* @7c */
else /* @7a */
rc = BAIL_OUT; /* @7a */
return(rc); /* @7a */
}
int _tmain(int argc, _TCHAR * argv[])
{
int rv;
rv = parse_cmd_line(argc, argv);
if(rv != 0)
return rv;
create_sync_objects();
if(!isChild) {
if(spawn_kids(argc, argv))
return 1;
} else {
SetEvent(event_parent);
}
rv = run_tests();
free_sync_objects();
cleanup();
return rv;
}
