From: Rémi Denis-Courmont Date: Sun, 28 Feb 2010 14:24:40 +0000 (+0200) Subject: Avoid namespace clash with normal getopt X-Git-Tag: 1.1.0-pre1~597 X-Git-Url: https://git.sesse.net/?a=commitdiff_plain;ds=sidebyside;h=430c69a6736848eee2032e5af4fc2b88cac18e0e;p=vlc Avoid namespace clash with normal getopt --- diff --git a/src/config/cmdline.c b/src/config/cmdline.c index 73e51af30d..2710f801fb 100644 --- a/src/config/cmdline.c +++ b/src/config/cmdline.c @@ -54,14 +54,13 @@ * * @warning This function is not re-entrant (because of getopt_long()). * It must be called with the module bank initialization global lock held. - * FIXME: this still breaks if getopt() is used outside of LibVLC. */ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, const char *ppsz_argv[], bool b_ignore_errors ) { int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0; module_t *p_parser; - struct option *p_longopts; + struct vlc_option *p_longopts; const char **argv_copy = NULL; /* Short options */ @@ -82,14 +81,14 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, * dealing with boolean to allow for --foo and --no-foo */ i_opts += p_parser->i_config_items + 2 * p_parser->i_bool_items; - p_longopts = malloc( sizeof(struct option) * (i_opts + 1) ); + p_longopts = malloc( sizeof(*p_longopts) * (i_opts + 1) ); if( p_longopts == NULL ) { module_list_free (list); return -1; } - psz_shortopts = malloc( sizeof( char ) * (2 * i_opts + 1) ); + psz_shortopts = malloc( 2 * i_opts + 1 ); if( psz_shortopts == NULL ) { free( p_longopts ); @@ -198,15 +197,16 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, module_list_free( list ); /* Close the longopts and shortopts structures */ - memset( &p_longopts[i_index], 0, sizeof(struct option) ); + memset( &p_longopts[i_index], 0, sizeof(*p_longopts) ); psz_shortopts[i_shortopts] = '\0'; /* * Parse the command line options */ - optind = 0; /* set to 0 to tell GNU getopt to reinitialize */ - while( ( i_cmd = vlc_getopt_long( *pi_argc, (char **)ppsz_argv, psz_shortopts, - p_longopts, &i_index ) ) != -1 ) + vlc_optind = 0; /* set to 0 to tell GNU getopt to reinitialize */ + while( ( i_cmd = vlc_getopt_long( *pi_argc, (char **)ppsz_argv, + psz_shortopts, + p_longopts, &i_index ) ) != -1 ) { /* A long option has been recognized */ if( i_cmd == 0 ) @@ -262,21 +262,21 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, case CONFIG_ITEM_MODULE_LIST_CAT: case CONFIG_ITEM_MODULE_CAT: var_Create( p_this, psz_name, VLC_VAR_STRING ); - var_SetString( p_this, psz_name, optarg ); + var_SetString( p_this, psz_name, vlc_optarg ); break; case CONFIG_ITEM_INTEGER: var_Create( p_this, psz_name, VLC_VAR_INTEGER ); var_SetInteger( p_this, psz_name, - strtol(optarg, NULL, 0)); + strtol(vlc_optarg, NULL, 0)); break; case CONFIG_ITEM_FLOAT: var_Create( p_this, psz_name, VLC_VAR_FLOAT ); - var_SetFloat( p_this, psz_name, us_atof(optarg) ); + var_SetFloat( p_this, psz_name, us_atof(vlc_optarg) ); break; case CONFIG_ITEM_KEY: var_Create( p_this, psz_name, VLC_VAR_INTEGER ); var_SetInteger( p_this, psz_name, - ConfigStringToKey( optarg ) ); + ConfigStringToKey( vlc_optarg ) ); break; case CONFIG_ITEM_BOOL: var_Create( p_this, psz_name, VLC_VAR_BOOL ); @@ -302,26 +302,26 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, case CONFIG_ITEM_MODULE_LIST: case CONFIG_ITEM_MODULE_LIST_CAT: var_Create( p_this, name, VLC_VAR_STRING ); - var_SetString( p_this, name, optarg ); + var_SetString( p_this, name, vlc_optarg ); break; case CONFIG_ITEM_INTEGER: var_Create( p_this, name, VLC_VAR_INTEGER ); if( i_cmd == 'v' ) { - if( optarg ) + if( vlc_optarg ) { - if( *optarg == 'v' ) /* eg. -vvv */ + if( *vlc_optarg == 'v' ) /* eg. -vvv */ { i_verbose++; - while( *optarg == 'v' ) + while( *vlc_optarg == 'v' ) { i_verbose++; - optarg++; + vlc_optarg++; } } else { - i_verbose += atoi( optarg ); /* eg. -v2 */ + i_verbose += atoi( vlc_optarg ); /* eg. -v2 */ } } else @@ -333,7 +333,7 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, else { var_SetInteger( p_this, name, - strtol(optarg, NULL, 0) ); + strtol(vlc_optarg, NULL, 0) ); } break; case CONFIG_ITEM_BOOL: @@ -350,13 +350,13 @@ int config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, { fputs( "vlc: unknown option" " or missing mandatory argument ", stderr ); - if( optopt ) + if( vlc_optopt ) { - fprintf( stderr, "`-%c'\n", optopt ); + fprintf( stderr, "`-%c'\n", vlc_optopt ); } else { - fprintf( stderr, "`%s'\n", ppsz_argv[optind-1] ); + fprintf( stderr, "`%s'\n", ppsz_argv[vlc_optind-1] ); } fputs( "Try `vlc --help' for more information.\n", stderr ); diff --git a/src/config/getopt.c b/src/config/getopt.c index e1db101c57..bec9fa3aed 100644 --- a/src/config/getopt.c +++ b/src/config/getopt.c @@ -49,7 +49,7 @@ Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ -char *optarg = NULL; +char *vlc_optarg = NULL; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller @@ -64,13 +64,13 @@ char *optarg = NULL; how much of ARGV has been scanned so far. */ /* 1003.2 says this must be 1 before any call. */ -int optind = 1; +int vlc_optind = 1; /* Formerly, initialization of getopt depended on optind==0, which causes problems with re-calling getopt as programs generally don't know that. */ -int __getopt_initialized = 0; +static int vlc_getopt_initialized = 0; /* The next char to be scanned in the option-element in which the last option character we returned was found. @@ -85,7 +85,7 @@ static char *nextchar; This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ -int optopt = '?'; +int vlc_optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. @@ -151,7 +151,7 @@ static void { int bottom = first_nonopt; int middle = last_nonopt; - int top = optind; + int top = vlc_optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. @@ -197,16 +197,16 @@ static void /* Update records for the slots the non-options now occupy. */ - first_nonopt += (optind - last_nonopt); - last_nonopt = optind; + first_nonopt += (vlc_optind - last_nonopt); + last_nonopt = vlc_optind; } /* Initialize the internal data when the first call is made. */ -static const char *_getopt_initialize(int, char *const *, const char *); +static const char *vlc_getopt_initialize(int, char *const *, const char *); static const char * - _getopt_initialize(argc, argv, optstring) + vlc_getopt_initialize(argc, argv, optstring) int argc; char *const *argv; const char *optstring; @@ -217,7 +217,7 @@ static const char * is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ - first_nonopt = last_nonopt = optind = 1; + first_nonopt = last_nonopt = vlc_optind = 1; nextchar = NULL; @@ -298,19 +298,19 @@ int int argc; char *const *argv; const char *optstring; - const struct option *longopts; + const struct vlc_option *restrict longopts; int *longind; { - optarg = NULL; + vlc_optarg = NULL; - if (!__getopt_initialized || optind == 0) + if (!vlc_getopt_initialized || vlc_optind == 0) { - optstring = _getopt_initialize(argc, argv, optstring); - optind = 1; /* Don't scan ARGV[0], the program name. */ - __getopt_initialized = 1; + optstring = vlc_getopt_initialize(argc, argv, optstring); + vlc_optind = 1; /* Don't scan ARGV[0], the program name. */ + vlc_getopt_initialized = 1; } -#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') +#define NONOPTION_P (argv[vlc_optind][0] != '-' || argv[vlc_optind][1] == '\0') if (nextchar == NULL || *nextchar == '\0') { @@ -318,27 +318,27 @@ int /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been moved back by the user (who may also have changed the arguments). */ - if (last_nonopt > optind) - last_nonopt = optind; - if (first_nonopt > optind) - first_nonopt = optind; + if (last_nonopt > vlc_optind) + last_nonopt = vlc_optind; + if (first_nonopt > vlc_optind) + first_nonopt = vlc_optind; if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ - if (first_nonopt != last_nonopt && last_nonopt != optind) + if (first_nonopt != last_nonopt && last_nonopt != vlc_optind) exchange((char **) argv); - else if (last_nonopt != optind) - first_nonopt = optind; + else if (last_nonopt != vlc_optind) + first_nonopt = vlc_optind; /* Skip any additional non-options and extend the range of non-options previously skipped. */ - while (optind < argc && NONOPTION_P) - optind++; - last_nonopt = optind; + while (vlc_optind < argc && NONOPTION_P) + vlc_optind++; + last_nonopt = vlc_optind; } /* The special ARGV-element `--' means premature end of options. @@ -346,28 +346,28 @@ int then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ - if (optind != argc && !strcmp(argv[optind], "--")) + if (vlc_optind != argc && !strcmp(argv[vlc_optind], "--")) { - optind++; + vlc_optind++; - if (first_nonopt != last_nonopt && last_nonopt != optind) + if (first_nonopt != last_nonopt && last_nonopt != vlc_optind) exchange((char **) argv); else if (first_nonopt == last_nonopt) - first_nonopt = optind; + first_nonopt = vlc_optind; last_nonopt = argc; - optind = argc; + vlc_optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ - if (optind == argc) + if (vlc_optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) - optind = first_nonopt; + vlc_optind = first_nonopt; return -1; } @@ -378,26 +378,26 @@ int { if (ordering == REQUIRE_ORDER) return -1; - optarg = argv[optind++]; + vlc_optarg = argv[vlc_optind++]; return 1; } /* We have found another option-ARGV-element. Skip the initial punctuation. */ - nextchar = (argv[optind] + 1 - + (argv[optind][1] == '-')); + nextchar = (argv[vlc_optind] + 1 + + (argv[vlc_optind][1] == '-')); } /* Decode the current option-ARGV-element. */ /* Check whether the ARGV-element is a long option. */ - if (argv[optind][1] == '-') + if (argv[vlc_optind][1] == '-') { char *nameend; - const struct option *p; - const struct option *pfound = NULL; + const struct vlc_option *p; + const struct vlc_option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = -1; @@ -434,35 +434,35 @@ int if (ambig && !exact) { nextchar += strlen(nextchar); - optind++; - optopt = 0; + vlc_optind++; + vlc_optopt = 0; return '?'; } if (pfound != NULL) { option_index = indfound; - optind++; + vlc_optind++; if (*nameend) { if (pfound->has_arg) - optarg = nameend + 1; + vlc_optarg = nameend + 1; else { nextchar += strlen(nextchar); - optopt = pfound->val; + vlc_optopt = pfound->val; return '?'; } } else if (pfound->has_arg) { - if (optind < argc) - optarg = argv[optind++]; + if (vlc_optind < argc) + vlc_optarg = argv[vlc_optind++]; else { nextchar += strlen(nextchar); - optopt = pfound->val; + vlc_optopt = pfound->val; return optstring[0] == ':' ? ':' : '?'; } } @@ -478,8 +478,8 @@ int } nextchar = (char *) ""; - optind++; - optopt = 0; + vlc_optind++; + vlc_optopt = 0; return '?'; } @@ -491,19 +491,19 @@ int /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') - ++optind; + ++vlc_optind; if (temp == NULL || c == ':') { - optopt = c; + vlc_optopt = c; return '?'; } /* Convenience. Treat POSIX -W foo same as long option --foo */ if (temp[0] == 'W' && temp[1] == ';') { char *nameend; - const struct option *p; - const struct option *pfound = NULL; + const struct vlc_option *p; + const struct vlc_option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = 0; @@ -512,14 +512,14 @@ int /* This is an option that requires an argument. */ if (*nextchar != '\0') { - optarg = nextchar; + vlc_optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ - optind++; + vlc_optind++; } - else if (optind == argc) + else if (vlc_optind == argc) { - optopt = c; + vlc_optopt = c; if (optstring[0] == ':') c = ':'; else @@ -529,12 +529,12 @@ int else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ - optarg = argv[optind++]; + vlc_optarg = argv[vlc_optind++]; /* optarg is now the argument, see if it's in the table of longopts. */ - for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) + for (nextchar = nameend = vlc_optarg; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match @@ -563,7 +563,7 @@ int if (ambig && !exact) { nextchar += strlen(nextchar); - optind++; + vlc_optind++; return '?'; } if (pfound != NULL) @@ -572,7 +572,7 @@ int if (*nameend) { if (pfound->has_arg) - optarg = nameend + 1; + vlc_optarg = nameend + 1; else { nextchar += strlen(nextchar); @@ -581,8 +581,8 @@ int } else if (pfound->has_arg) { - if (optind < argc) - optarg = argv[optind++]; + if (vlc_optind < argc) + vlc_optarg = argv[vlc_optind++]; else { nextchar += strlen(nextchar); @@ -607,14 +607,14 @@ int /* This is an option that requires an argument. */ if (*nextchar != '\0') { - optarg = nextchar; + vlc_optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ - optind++; + vlc_optind++; } - else if (optind == argc) + else if (vlc_optind == argc) { - optopt = c; + vlc_optopt = c; if (optstring[0] == ':') c = ':'; else @@ -623,7 +623,7 @@ int else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ - optarg = argv[optind++]; + vlc_optarg = argv[vlc_optind++]; nextchar = NULL; } return c; diff --git a/src/config/vlc_getopt.h b/src/config/vlc_getopt.h index 72b2341110..3dbd1a55a4 100644 --- a/src/config/vlc_getopt.h +++ b/src/config/vlc_getopt.h @@ -28,7 +28,7 @@ Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ - extern char *optarg; +extern char *vlc_optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller @@ -42,11 +42,11 @@ Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ - extern int optind; +extern int vlc_optind; /* Set to an option character which was unrecognized. */ - extern int optopt; +extern int vlc_optopt; /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector @@ -68,15 +68,15 @@ one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ - struct option - { - const char *name; - bool has_arg; - int *flag; - int val; - }; +struct vlc_option +{ + const char *name; + bool has_arg; + int *flag; + int val; +}; - extern int vlc_getopt_long(int argc, char *const *argv, const char *shortopts, - const struct option *longopts, int *longind); +extern int vlc_getopt_long(int argc, char *const *argv, const char *shortopts, + const struct vlc_option *longopts, int *longind); #endif /* VLC_GETOPT_H */ diff --git a/src/libvlc.c b/src/libvlc.c index 0a7d11d338..226147e2fb 100644 --- a/src/libvlc.c +++ b/src/libvlc.c @@ -531,6 +531,9 @@ int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc, /* * Override configuration with command line settings */ + /* config_LoadCmdLine(), DBus (below) and Win32-specific use vlc_optind, + * vlc_optarg and vlc_optopt globals. This is not thread-safe!! */ +#warning BUG! if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, false ) ) { #ifdef WIN32 @@ -603,7 +606,7 @@ int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc, dbus_message_unref( p_test_reply ); msg_Warn( p_libvlc, "Another Media Player is running. Exiting"); - for( i_input = optind;i_input < i_argc;i_input++ ) + for( i_input = vlc_optind; i_input < i_argc;i_input++ ) { msg_Dbg( p_libvlc, "Adds %s to the running Media Player", ppsz_argv[i_input] ); @@ -1194,12 +1197,12 @@ static int GetFilenames( libvlc_int_t *p_vlc, int i_argc, const char *ppsz_argv[ /* We assume that the remaining parameters are filenames * and their input options */ - for( i_opt = i_argc - 1; i_opt >= optind; i_opt-- ) + for( i_opt = i_argc - 1; i_opt >= vlc_optind; i_opt-- ) { i_options = 0; /* Count the input options */ - while( *ppsz_argv[ i_opt ] == ':' && i_opt > optind ) + while( *ppsz_argv[ i_opt ] == ':' && i_opt > vlc_optind ) { i_options++; i_opt--; diff --git a/src/win32/specific.c b/src/win32/specific.c index 20050250fe..c3e3a75c2a 100644 --- a/src/win32/specific.c +++ b/src/win32/specific.c @@ -221,24 +221,24 @@ void system_Configure( libvlc_int_t *p_this, int *pi_argc, const char *ppsz_argv /* We assume that the remaining parameters are filenames * and their input options */ - if( *pi_argc - 1 >= optind ) + if( *pi_argc - 1 >= vlc_optind ) { COPYDATASTRUCT wm_data; int i_opt; vlc_ipc_data_t *p_data; size_t i_data = sizeof (*p_data); - for( i_opt = optind; i_opt < *pi_argc; i_opt++ ) + for( i_opt = vlc_optind; i_opt < *pi_argc; i_opt++ ) { i_data += sizeof (size_t); i_data += strlen( ppsz_argv[ i_opt ] ) + 1; } p_data = malloc( i_data ); - p_data->argc = *pi_argc - optind; + p_data->argc = *pi_argc - vlc_optind; p_data->enqueue = var_InheritBool( p_this, "playlist-enqueue" ); i_data = 0; - for( i_opt = optind; i_opt < *pi_argc; i_opt++ ) + for( i_opt = vlc_optind; i_opt < *pi_argc; i_opt++ ) { size_t i_len = strlen( ppsz_argv[ i_opt ] ) + 1; /* Windows will never switch to an architecture