int main(int argc, char *argv[])
{
/* update progname from argv[0] */
set_progname(argv[0]);
const struct ap_Option options[] = {
{'h', "help", ap_no, 0, 0},
{'v', "version", ap_no, 0, 0},
{0, 0, ap_no, 0, 0}
};
if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
critx("could not allocate memory for option parser");
if (ap_error(&parser)) {
errx("%s", ap_error(&parser));
usage(EXIT_FAILURE);
}
/* parse command line */
for (int argind = 0; argind < ap_arguments(&parser); argind++) {
const int code = ap_code(&parser, argind);
switch (code) {
case 0:
break;
case 'h':
usage(EXIT_SUCCESS);
break;
case 'v':
fprintf(stderr, "%s %s\n%s\n%s\n\n%s\n", progname,
FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
exit(EXIT_SUCCESS);
break;
default:
errx("uncaught option: %s", ap_argument(&parser, argind));
usage(EXIT_FAILURE);
break;
}
}
if (!ap_arguments(&parser)) {
errx("no address given");
usage(EXIT_FAILURE);
}
xmlrpc_env rpc_env;
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (int argind = 0; argind < ap_arguments(&parser); argind++)
/* if non-option, it is an address */
if (!ap_code(&parser, argind))
stop_flows(ap_argument(&parser, argind));
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
ap_free(&parser);
}
const char *ap_argument(const Arg_parser * ap, const int i)
{
if (i >= 0 && i < ap_arguments(ap))
return ap->data[i].argument;
else
return "";
}
int ap_code(const Arg_parser * ap, const int i)
{
if (i >= 0 && i < ap_arguments(ap))
return ap->data[i].code;
else
return 0;
}
int main( const int argc, const char * const argv[] )
{
int argind;
bool loose = false;
const struct ap_Option options[] =
{
{ 'G', "traditional", ap_no },
{ 'h', "help", ap_no },
{ 'l', "loose-exit-status", ap_no },
{ 'p', "prompt", ap_yes },
{ 'r', "restricted", ap_no },
{ 's', "quiet", ap_no },
{ 's', "silent", ap_no },
{ 'v', "verbose", ap_no },
{ 'V', "version", ap_no },
{ 0 , 0, ap_no } };
struct Arg_parser parser;
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Memory exhausted.", 0, false ); return 1; }
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, true ); return 1; }
invocation_name = argv[0];
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
const char * const arg = ap_argument( &parser, argind );
if( !code ) break; /* no more options */
switch( code )
{
case 'G': traditional_ = true; break; /* backward compatibility */
case 'h': show_help(); return 0;
case 'l': loose = true; break;
case 'p': set_prompt( arg ); break;
case 'r': restricted_ = true; break;
case 's': scripted_ = true; break;
case 'v': set_verbose(); break;
case 'V': show_version(); return 0;
default : show_error( "internal error: uncaught option.", 0, false );
return 3;
}
} /* end process options */
setlocale( LC_ALL, "" );
if( !init_buffers() ) return 1;
while( argind < ap_arguments( &parser ) )
{
const char * const arg = ap_argument( &parser, argind );
if( !strcmp( arg, "-" ) ) { scripted_ = true; ++argind; continue; }
if( may_access_filename( arg ) )
{
if( read_file( arg, 0 ) < 0 && is_regular_file( 0 ) )
return 2;
else if( arg[0] != '!' ) set_def_filename( arg );
}
else
{
fputs( "?\n", stderr );
if( arg[0] ) set_error_msg( "Invalid filename" );
if( is_regular_file( 0 ) ) return 2;
}
break;
}
ap_free( &parser );
return main_loop( loose );
}
int main( const int argc, const char * const argv[] )
{
char verbose = 0;
const struct ap_Option options[] =
{
{ 'H', "hidden", ap_no },
{ 'V', "version", ap_no },
{ 'a', "append", ap_no },
{ 'b', "block", ap_yes },
{ 'c', "casual", ap_maybe },
{ 'h', "help", ap_no },
{ 'o', 0, ap_yes },
{ 'q', "quiet", ap_no },
{ 'u', "uncaught", ap_no },
{ 'v', "verbose", ap_no },
{ 256, "orphan", ap_no },
{ 0, 0, ap_no } };
struct Arg_parser parser;
int argind;
invocation_name = argv[0];
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Memory exhausted.", 0, 0 ); return 1; }
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, 1 ); return 1; }
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
if( !code ) break; /* no more options */
switch( code )
{
case 'H': break; /* example, do nothing */
case 'V': show_version(); return 0;
case 'a': break; /* example, do nothing */
case 'b': break; /* example, do nothing */
case 'c': break; /* example, do nothing */
case 'h': show_help( verbose ); return 0;
case 'o': break; /* example, do nothing */
case 'q': verbose = 0; break;
/* case 'u': break; */ /* intentionally not caught */
case 'v': verbose = 1; break;
case 256: break; /* example, do nothing */
default : internal_error( "uncaught option" );
}
} /* end process options */
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
const char * const arg = ap_argument( &parser, argind );
if( code ) /* option */
{
const char * const name = optname( code, options );
if( !name[1] )
printf( "option '-%c'", name[0] );
else
printf( "option '--%s'", name );
if( arg[0] )
printf( " with argument '%s'", arg );
}
else /* non-option */
printf( "non-option argument '%s'", arg );
printf( "\n" );
}
if( !ap_arguments( &parser ) ) printf( "Hello, world!\n" );
return 0;
}
/******************************************************************//**
* @brief Parsing commandline arguments.
*
* @param[in] argc - count of arguments strings
* @param[in] argv[] - array of arguments strings
*
* @retval err_result_ok - if execution was successful
* @retval err_not_found - if no arguments found
* @retval err_result_error - if parsing was unsuccessful
*********************************************************************/
errType process_cmdLine(int argc, char *argv[])
{
/**
* @todo reorganize process to external library
*/
errType result=err_result_ok;
/// 1. Define arguments type: with (\a ap_yes) or without (\a ap_no) parameters
const ap_Option options[] =
{
{ 'V', "version", ap_no },
{ 'h', "help", ap_no },
{ 'v', "verbose", ap_no },
{ 'u', "srv_udp_port", ap_yes},
{ 's', "eqp_udp_send_port", ap_yes},
{ 'r', "eqp_udp_recv_port", ap_yes},
{ 'i', "eqp_ip_addr", ap_yes},
{ 0, 0, ap_no } };
Arg_parser parser;
int argind;
///2. Initialize arguments parser ::ap_init
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Необходимо задать аргументы запуска!", 0, 0 ); return err_not_found; }
///3. Check for parsing errors ::ap_error
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, 1 ); return err_result_error; }
///4. Execute all arguments after it parsing
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
/// - get code of argument ::ap_code
const int code = ap_code( &parser, argind );
if( !code ) break; // no more options
/// - switch with argument code value
switch( code ){
/// - execute
case 'V': show_version(); return err_extra;
case 'h': show_help( verbose_level ); return err_extra;
case 'v': verbose_level = 1; break;
case 'u': break;
case 's': break;
case 'r': break;
case 'i': break;
default : internal_error( "неподдерживаемая опция" ); return err_extra;
}
} // end process options
///4. Execute only arguments with parameters after it parsing
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
/// - get code of argument ::ap_code
const int code = ap_code( &parser, argind );
/// - get argument parameter ::ap_argument
const char * arg = ap_argument( &parser, argind );
/// - switch with argument code value
switch(code){
/// - execute
case 'u':
wUdp=atol(arg);
break;
case 's':
eq_udp_sending_port=atol(arg);
break;
case 'r':
eq_udp_listen_port=atol(arg);
break;
case 'i':
strcpy(eq_ip_addr, arg);
inet_aton(eq_ip_addr,&equipAddr);
break;
default:
break;
}
if( !code ) { // option
// non-option
printf( "аргумент `%s' не является опцией", arg );
printf( "\n" );
result=err_result_error;
}
}
if (!ap_arguments( &parser )) result=err_result_ok;
return result;
}
