getopt.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_optarg_ctx
struct	option

Macros
#define	BAD_OPTION   '\0'
#define	no_argument   0
#define	required_argument   1
#define	optional_argument   2

Typedefs
typedef struct _optarg_ctx	optarg_ctx
typedef struct _optarg_ctx *	P_optarg_ctx

Functions
void	getopt_init (optarg_ctx *o)
int	getopt (optarg_ctx *o, int argc, WCHAR *const *argv, const WCHAR *shortopts)
int	getopt_long (optarg_ctx *o, int argc, WCHAR *const *argv, const WCHAR *shortopts, const struct option *longopts, int *longind)
int	getopt_long_only (optarg_ctx *o, int argc, WCHAR *const *argv, const WCHAR *shortopts, const struct option *longopts, int *longind)
int	_getopt_internal (optarg_ctx *o, int argc, WCHAR *const *argv, const WCHAR *shortopts, const struct option *longopts, int *longind, int long_only)

Macro Definition Documentation

BAD_OPTION

#define BAD_OPTION   '\0'

Definition at line 14 of file getopt.h.

no_argument

#define no_argument   0

Definition at line 122 of file getopt.h.

optional_argument

#define optional_argument   2

Definition at line 124 of file getopt.h.

required_argument

#define required_argument   1

Definition at line 123 of file getopt.h.

Typedef Documentation

optarg_ctx

typedef struct _optarg_ctx optarg_ctx

P_optarg_ctx

typedef struct _optarg_ctx * P_optarg_ctx

Function Documentation

_getopt_internal()

int _getopt_internal	(	optarg_ctx *	o,
		int	argc,
		WCHAR *const *	argv,
		const WCHAR *	shortopts,
		const struct option *	longopts,
		int *	longind,
		int	long_only
	)

Definition at line 157 of file getopt.cpp.

{
    int option_index;
 
    o->optarg = 0;
 
    /* Initialize the internal data when the first call is made.
       Start processing options with ARGV-element 1 (since ARGV-element 0
       is the program name); the sequence of previously skipped
       non-option ARGV-elements is empty.  */
 
    if (o->optind == 0)
    {
        o->first_nonopt = o->last_nonopt = o->optind = 1;
 
        o->nextchar = NULL;
 
        /* Determine how to handle the ordering of options and nonoptions.  */
 
        if (optstring[0] == '-') {
            ordering = RETURN_IN_ORDER;
            ++optstring;
        } else if (optstring[0] == '+') {
            ordering = REQUIRE_ORDER;
            ++optstring;
/*        } else if (getenv ("POSIXLY_CORRECT") != NULL) {
            ordering = REQUIRE_ORDER;*/
        } else {
            ordering = PERMUTE;
        }
    }
 
    if (o->nextchar == NULL || *(o->nextchar) == '\0')
    {
        if (ordering == PERMUTE)
        {
            /* If we have just processed some options following some non-options,
               exchange them so that the options come first.  */
 
            if (o->first_nonopt != o->last_nonopt && o->last_nonopt != o->optind) {
                exchange (o, (WCHAR **) argv);
            } else if (o->last_nonopt != o->optind) {
                o->first_nonopt = o->optind;
            }
 
            /* Now skip any additional non-options
               and extend the range of non-options previously skipped.  */
 
            while (o->optind < argc
                   && (argv[o->optind][0] != '-' || argv[o->optind][1] == '\0')
                  ) {
                o->optind++;
            }
            o->last_nonopt = o->optind;
        }
 
        /* Special ARGV-element `--' means premature end of options.
       Skip it like a null option,
       then exchange with previous non-options as if it were an option,
       then skip everything else like a non-option.  */
 
        if (o->optind != argc && !my_strcmp (argv[o->optind], L"--"))
        {
            o->optind++;
 
            if (o->first_nonopt != o->last_nonopt && o->last_nonopt != o->optind) {
                exchange (o, (WCHAR **) argv);
            } else if (o->first_nonopt == o->last_nonopt) {
                o->first_nonopt = o->optind;
            }
            o->last_nonopt = argc;
 
            o->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 (o->optind == argc)
        {
            /* Set the next-arg-index to point at the non-options
               that we previously skipped, so the caller will digest them.  */
            if (o->first_nonopt != o->last_nonopt)
                o->optind = o->first_nonopt;
            return EOF;
        }
 
        /* If we have come to a non-option and did not permute it,
       either stop the scan or describe it to the caller and pass it by.  */
 
        if ((argv[o->optind][0] != '-' || argv[o->optind][1] == '\0'))
        {
            if (ordering == REQUIRE_ORDER)
                return EOF;
            o->optarg = argv[o->optind++];
            return 1;
        }
 
         /* We have found another option-ARGV-element.
        Start decoding its characters.  */
        o->nextchar = (argv[o->optind] + 1
            + (longopts != NULL && argv[o->optind][1] == '-'));
    }
 
    if (longopts != NULL
        && ((argv[o->optind][0] == '-'
         && (argv[o->optind][1] == '-' || long_only))
        ))
    {
        const struct option *p;
        WCHAR *s = o->nextchar;
        int exact = 0;
        int ambig = 0;
        const struct option *pfound = NULL;
        int indfound = 0;
 
        while (*s && *s != '=')
            s++;
 
        /* Test all options for either exact match or abbreviated matches.  */
        for (p = longopts, option_index = 0;
             p->name;
             p++, option_index++)
        if ( (p->val) && (!my_strncmp (p->name, o->nextchar, s - o->nextchar)) )
        {
            if (s - o->nextchar == (int)my_strlen (p->name))
            {
                /* Exact match found.  */
                pfound = p;
                indfound = option_index;
                exact = 1;
                break;
            } else if (pfound == NULL) {
                /* First nonexact match found.  */
                pfound = p;
                indfound = option_index;
            } else {
              /* Second nonexact match found.  */
                ambig = 1;
            }
        }
 
        if (ambig && !exact) {
            if (o->opterr) {
                UDFPrint(("%ws: option `%s' is ambiguous\n",
                     argv[0], argv[o->optind]));
            }
            o->nextchar += my_strlen (o->nextchar);
            o->optind++;
            return BAD_OPTION;
        }
 
        if (pfound != NULL)
        {
            option_index = indfound;
            o->optind++;
            if (*s) {
                /* Don't test has_arg with >, because some C compilers don't
               allow it to be used on enums.  */
                if (pfound->has_arg) {
                    o->optarg = s + 1;
                } else {
                    if (o->opterr) {
                        if (argv[o->optind - 1][1] == '-') {
                            /* --option */
                            UDFPrint((
                                 "%ws: option `--%ws' doesn't allow an argument\n",
                                 argv[0], pfound->name));
                        } else {
                            /* +option or -option */
                            UDFPrint((
                                 "%ws: option `%c%ws' doesn't allow an argument\n",
                                 argv[0], argv[o->optind - 1][0], pfound->name));
                        }
                    }
                    o->nextchar += my_strlen (o->nextchar);
                    return BAD_OPTION;
                }
            }
            else if (pfound->has_arg == 1)
            {
                if (o->optind < argc) {
                    o->optarg = argv[(o->optind)++];
                } else {
                    if (o->opterr)
                        UDFPrint(("%ws: option `%ws' requires an argument\n",
                           argv[0], argv[o->optind - 1]));
                    o->nextchar += my_strlen (o->nextchar);
                    return optstring[0] == ':' ? ':' : BAD_OPTION;
                }
            }
            o->nextchar += my_strlen (o->nextchar);
            if (longind != NULL)
                *longind = option_index;
            if (pfound->flag) {
                *(pfound->flag) = pfound->val;
                return 0;
            }
            return pfound->val;
        }
         /* Can't find it as a long option.  If this is not getopt_long_only,
        or the option starts with '--' or is not a valid short
        option, then it's an error.
        Otherwise interpret it as a short option.  */
        if (!long_only || argv[o->optind][1] == '-'
            || my_index (optstring, *(o->nextchar)) == NULL)
        {
            if (o->opterr)
            {
                if (argv[o->optind][1] == '-') {
                    /* --option */
                    UDFPrint(("%ws: unrecognized option `--%ws'\n",
                         argv[0], o->nextchar));
                } else {
                    /* +option or -option */
                    UDFPrint(("%ws: unrecognized option `%c%ws'\n",
                         argv[0], argv[o->optind][0], o->nextchar));
                }
            }
            o->nextchar = (WCHAR *) L"";
            o->optind++;
            return BAD_OPTION;
        }
    }
 
    /* Look at and handle the next option-character.  */
 
    {
        WCHAR c = *(o->nextchar)++;
        WCHAR *temp = my_index (optstring, c);
 
        /* Increment `optind' when we start to process its last character.  */
        if (*(o->nextchar) == '\0')
          ++(o->optind);
 
        if (temp == NULL || c == ':')
        {
            if (o->opterr)
            {
                UDFPrint(("%ws: illegal option -- %c\n", argv[0], c));
            }
            o->optopt = c;
            return BAD_OPTION;
        }
        if (temp[1] == ':')
        {
            if (temp[2] == ':')
            {
                /* This is an option that accepts an argument optionally.  */
                if (*(o->nextchar) != '\0') {
                    o->optarg = o->nextchar;
                    o->optind++;
                } else {
                    o->optarg = 0;
                }
                o->nextchar = NULL;
            }
            else
            {
                /* This is an option that requires an argument.  */
                if (*(o->nextchar) != '\0')
                {
                    o->optarg = o->nextchar;
                    /* If we end this ARGV-element by taking the rest as an arg,
                       we must advance to the next element now.  */
                    o->optind++;
                }
                else if (o->optind == argc)
                {
                    if (o->opterr)
                    {
                        UDFPrint(("%ws: option requires an argument -- %c\n",
                             argv[0], c));
                    }
                    o->optopt = c;
                    if (optstring[0] == ':') {
                        c = ':';
                    } else {
                        c = BAD_OPTION;
                    }
                }
                else
                {
                    /* We already incremented `optind' once;
                   increment it again when taking next ARGV-elt as argument.  */
                    o->optarg = argv[o->optind++];
                }
                o->nextchar = NULL;
            }
        }
        return c;
    }
}

Referenced by getopt(), getopt_long(), and getopt_long_only().

getopt()

int getopt	(	optarg_ctx *	o,
		int	argc,
		WCHAR *const *	argv,
		const WCHAR *	shortopts
	)

Definition at line 459 of file getopt.cpp.

{
    return _getopt_internal (o, argc, argv, optstring,
               (const struct option *) 0,
               (int *) 0,
               0);
}

getopt_init()

void getopt_init

(

optarg_ctx *

o

)

Definition at line 61 of file getopt.cpp.

                           {
 
    o->optarg = NULL;
    o->optind = 0;
    o->optopt = BAD_OPTION;
    o->opterr = 1;
}

getopt_long()

int getopt_long	(	optarg_ctx *	o,
		int	argc,
		WCHAR *const *	argv,
		const WCHAR *	shortopts,
		const struct option *	longopts,
		int *	longind
	)

Definition at line 472 of file getopt.cpp.

{
  return _getopt_internal (o, argc, argv, options, long_options, opt_index, 0);
}

getopt_long_only()

int getopt_long_only	(	optarg_ctx *	o,
		int	argc,
		WCHAR *const *	argv,
		const WCHAR *	shortopts,
		const struct option *	longopts,
		int *	longind
	)

Referenced by check_option(), and main().