/**********************************************************************
* main
*/
int main( int argc, char *argv[] )
{
char error[1024];
int i;
init_thread_hook();
if (!getenv( "WINELOADERNOEXEC" )) /* first time around */
{
static char noexec[] = "WINELOADERNOEXEC=1";
putenv( noexec );
check_command_line( argc, argv );
if (pre_exec())
{
wine_init_argv0_path( argv[0] );
wine_exec_wine_binary( NULL, argv, getenv( "WINELOADER" ));
fprintf( stderr, "wine: could not exec the wine loader\n" );
exit(1);
}
}
#ifndef __APPLE__
if (wine_main_preload_info)
#endif
{
for (i = 0; wine_main_preload_info[i].size; i++)
reserve_area( wine_main_preload_info[i].addr, wine_main_preload_info[i].size );
}
wine_init( argc, argv, error, sizeof(error) );
fprintf( stderr, "wine: failed to initialize: %s\n", error );
exit(1);
}
/**********************************************************************
* main
*/
int main( int argc, char *argv[] )
{
char error[1024];
int i;
check_command_line( argc, argv );
if (wine_main_preload_info)
{
for (i = 0; wine_main_preload_info[i].size; i++)
reserve_area( wine_main_preload_info[i].addr, wine_main_preload_info[i].size );
}
wine_pthread_set_functions( &pthread_functions, sizeof(pthread_functions) );
wine_init( argc, argv, error, sizeof(error) );
fprintf( stderr, "wine: failed to initialize: %s\n", error );
exit(1);
}
int
main (int argc, gchar *argv[])
{
if (!check_command_line (argc, argv,
&command, &playlist_name, &object_id)) {
g_error ("Please, provide one of these sets of arguments:\n"
" create <playlist-name>\n"
" remove <playlist-name>\n"
" show <playlist-name>\n"
" add-item <playlist-name> <object-id>\n",
" remove-item <playlist-name> <object-id>\n");
}
g_type_init ();
mafw_log_init (G_LOG_DOMAIN ":ALL");
g_timeout_add (100, execute_command, NULL);
main_loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (main_loop);
return 0;
}
int main(int argc, char * argv[]) {
int ret;
/*
* Initialize:
* - pirates_number from command line
* - ninjas_number from command line
* - time_to_run from command line
*/
srandom(time(NULL));
/* Number of Pirates */
int pirates_number = 0;
/* Number of Ninjas */
int ninjas_number = 0;
/* Time to run in seconds */
time_to_run = 0;
int valid = check_command_line(argc,argv,&pirates_number,&ninjas_number,&time_to_run);
printf("Time to Live (seconds) : %d \n",time_to_run);
printf("Number of Pirates : %d \n",pirates_number);
printf("Number of Ninjas : %d \n",ninjas_number);
printf("-------------------------------\n");
pthread_t pirates_threads[pirates_number];
pthread_t ninjas_threads[ninjas_number];
if(valid)
{
/*
* Initialize:
* - semaphore_t mutex_register = 1;
* - semaphore_t mutex_ninja_count = 1;
* - semaphore_t mutex_pirate_count = 1;
* - semaphore_t mutex_department = 1;
* - semaphore_t mutex_team = 2;
*/
if( 0 != (ret = semaphore_create(&mutex_register, 1)) ) {
fprintf(stderr, "Error: semaphore_create() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_create(&mutex_ninja_count, 1)) ) {
fprintf(stderr, "Error: semaphore_create() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_create(&mutex_pirate_count, 1)) ) {
fprintf(stderr, "Error: semaphore_create() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_create(&mutex_department, 1)) ) {
fprintf(stderr, "Error: semaphore_create() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_create(&mutex_team, 2)) ) {
fprintf(stderr, "Error: semaphore_create() failed with %d\n", ret);
return -1;
}
/*
* int* pirate_enter;
* int* pirate_left;
* int* ninja_enter;
* int* ninja_left;
*/
pirate_enter = (int *)malloc(sizeof(int) * pirates_number);
pirate_left = (int *)malloc(sizeof(int) * pirates_number);
ninja_enter = (int *)malloc(sizeof(int) * ninjas_number);
ninja_left = (int *)malloc(sizeof(int) *ninjas_number);
/*
* Create threads
*/
/* Create Pirates */
for(int i = 0 ; i <pirates_number ; i++)
{
// printf("In Main(): Creating thread %d\n", i);
ret = pthread_create(&pirates_threads[i],
NULL,
pirate,
(void *)(intptr_t)i);
if(0 != ret ) {
fprintf(stderr, "Error: Cannot Create thread\n");
exit(-1);
}
}
/* Create Ninjas */
for(int i = 0 ; i <ninjas_number ;i++)
{
// printf("In Main(): Creating thread %d\n", i);
ret = pthread_create(&ninjas_threads[i],
NULL,
ninja,
(void *)(intptr_t)i);
if(0 != ret ) {
fprintf(stderr, "Error: Cannot Create thread\n");
exit(-1);
}
}
tstart = (double)clock()/CLOCKS_PER_SEC;
}else{
printf("Error: valid input command line\n");
pthread_exit(NULL);
}
/*
* Join Thread(s)
*/
/* Join pirates thread */
for(int i = 0; i < pirates_number; ++i ) {
ret = pthread_join(pirates_threads[i], NULL);
if( 0 != ret ) {
fprintf(stderr, "Error: Cannot Join Thread %d\n", i);
exit(-1);
}
}
/* Join ninjas thread */
for(int i = 0; i < ninjas_number; ++i ) {
ret = pthread_join(ninjas_threads[i], NULL);
if( 0 != ret ) {
fprintf(stderr, "Error: Cannot Join Thread %d\n", i);
exit(-1);
}
}
printf("-------------------------\n");
/*
* Output enter & left
*/
for(int i = 0 ; i < pirates_number ; i++)
{
printf("Pirate %d : Entered %d / Left %d\n",i,pirate_enter[i],pirate_left[i]);
}
for(int i = 0 ; i < ninjas_number ; i++)
{
printf("Ninja %d : Entered %d / Left %d\n",i,ninja_enter[i],ninja_left[i]);
}
/*
* Cleanup
*/
if( 0 != (ret = semaphore_destroy(&mutex_register)) ) {
fprintf(stderr, "Error: semaphore_destroy() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_destroy(&mutex_department)) ) {
fprintf(stderr, "Error: semaphore_destroy() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_destroy(&mutex_team)) ) {
fprintf(stderr, "Error: semaphore_destroy() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_destroy(&mutex_ninja_count)) ) {
fprintf(stderr, "Error: semaphore_destroy() failed with %d\n", ret);
return -1;
}
if( 0 != (ret = semaphore_destroy(&mutex_pirate_count)) ) {
fprintf(stderr, "Error: semaphore_destroy() failed with %d\n", ret);
return -1;
}
pthread_exit(NULL);
return 0;
}
int parse_command_line(struct modbus_params_t *params, int argc, char **argv)
{
int rs;
int rc = RESULT_OK;
int option_index;
if (argc < 2) {
ERR("%s: Could not parse arguments\n", argv[0]);
print_help();
return RESULT_WRONG_ARG;
};
load_defaults(params);
while (1) {
rs = getopt_long(argc, argv, short_options, long_options, &option_index);
if (rs == -1)
break;
switch (rs) {
case 'v':
params->verbose++;
dbg_set_level(params->verbose);
break;
case 'h':
print_help();
return RESULT_PRINT_HELP;
/* MODBUS TCP */
case 'H':
params->host = optarg;
break;
case 'p':
params->mport = optarg;
break;
#if LIBMODBUS_VERSION_MAJOR >= 3
/* MODBUS RTU */
case 'S':
params->serial = optarg;
break;
case OPT_SERIAL_MODE:
rc = parse_int_param(optarg, ¶ms->serial_mode);
break;
case 'b':
rc = parse_int_param(optarg, ¶ms->serial_bps);
break;
case OPT_SERIAL_PARITY:
params->serial_parity = (optarg) ? toupper(*optarg) : '\0';
break;
case OPT_SERIAL_DATA_BITS:
rc = parse_int_param(optarg, ¶ms->serial_data_bits);
break;
case OPT_SERIAL_STOP_BITS:
rc = parse_int_param(optarg, ¶ms->serial_stop_bits);
break;
#endif
case OPT_FILE:
params->file = optarg;
break;
case 'd':
rc = parse_int_param(optarg, ¶ms->devnum);
break;
case 'a':
rc = parse_int_param(optarg, ¶ms->sad);
if (params->sad <= 0) {
ERR("Address should be greater than zero: %s\n", optarg);
rc = RESULT_WRONG_ARG;
}
params->sad--; /* register/bit address starts from 0 */
break;
case 'f':
rc = parse_int_param(optarg, ¶ms->nf);
break;
case 'F':
rc = parse_int_param(optarg, ¶ms->format);
break;
case 'w':
if (parse_range(optarg, ¶ms->warn_range) != 0) {
ERR("can't parse warning range %s\n", optarg);
rc = RESULT_WRONG_ARG;
}
break;
case 'c':
if (parse_range(optarg, ¶ms->crit_range) != 0) {
ERR("can't parse critical range %s\n", optarg);
rc = RESULT_WRONG_ARG;
}
break;
case 'n':
params->nc = 1;
break;
case 'i':
params->inverse_words = 1;
break;
case 's':
params->swap_bytes = 1;
break;
case 't':
rc = parse_int_param(optarg, ¶ms->tries);
break;
case 'N':
params->nnc = 1;
break;
case 'm':
rc = parse_double_param(optarg, ¶ms->perf_min);
params->perf_min_en = 1;
break;
case 'M':
rc = parse_double_param(optarg, ¶ms->perf_max);
params->perf_max_en = 1;
break;
case 'L':
params->perf_label = optarg;
break;
case 'P':
params->perf_data = 1;
break;
case OPT_DUMP_FILE:
params->dump_file = optarg;
break;
case OPT_DUMP:
params->dump = 1;
break;
case OPT_DUMP_SIZE:
rc = parse_int_param(optarg, ¶ms->dump_size);
break;
case OPT_DUMP_FORMAT:
rc = parse_int_param(optarg, ¶ms->dump_format);
switch (params->dump_format) {
case DUMP_FMT_BIN:
params->format = FORMAT_DUMP_BIN;
break;
case DUMP_FMT_HEX:
params->format = FORMAT_DUMP_HEX;
break;
case DUMP_FMT_DEC:
params->format = FORMAT_DUMP_DEC;
break;
}
break;
case OPT_LOCK_FILE_IN:
params->lock_file_in = optarg;
break;
case OPT_LOCK_FILE_OUT:
params->lock_file_out = optarg;
break;
case OPT_GAIN:
rc = parse_double_param(optarg, ¶ms->gain);
break;
case OPT_OFFSET:
rc = parse_double_param(optarg, ¶ms->offset);
break;
case OPT_VERSION:
print_version();
rc = RESULT_PRINT_HELP;
break;
case '?':
default:
rc = RESULT_PRINT_HELP;
};
if (rc != RESULT_OK)
return rc;
}; /* while(1) */
return check_command_line(params, argc, argv);
}
