1

/* from http://www.pwilson.net/getopt.html */

     2

     3

/* Getopt for GNU.

     4

   NOTE: getopt is now part of the C library, so if you don't know what

     5

   "Keep this file name-space clean" means, talk to drepper@gnu.org

     6

   before changing it!

     7

   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001

     8

        Free Software Foundation, Inc.

     9

   This file is part of the GNU C Library.

    10

    11

   The GNU C Library is free software; you can redistribute it and/or

    12

   modify it under the terms of the GNU Lesser General Public

    13

   License as published by the Free Software Foundation; either

    14

   version 2.1 of the License, or (at your option) any later version.

    15

    16

   The GNU C Library is distributed in the hope that it will be useful,

    17

   but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

   Lesser General Public License for more details.

    20

    21

   You should have received a copy of the GNU Lesser General Public

    22

   License along with the GNU C Library; if not, write to the Free

    23

   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

    24

   02111-1307 USA.  */

    25

    26

/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.

    27

   Ditto for AIX 3.2 and <stdlib.h>.  */

    28

#ifndef _NO_PROTO

    29

# define _NO_PROTO

    30

#endif

    31

    32

#ifdef HAVE_CONFIG_H

    33

# include <config.h>

    34

#endif

    35

    36

#if !defined __STDC__ || !__STDC__

    37

/* This is a separate conditional since some stdc systems

    38

   reject `defined (const)'.  */

    39

# ifndef const

    40

#  define const

    41

# endif

    42

#endif

    43

    44

#include <stdio.h>

    45

    46

/* Comment out all this code if we are using the GNU C Library, and are not

    47

   actually compiling the library itself.  This code is part of the GNU C

    48

   Library, but also included in many other GNU distributions.  Compiling

    49

   and linking in this code is a waste when using the GNU C library

    50

   (especially if it is a shared library).  Rather than having every GNU

    51

   program understand `configure --with-gnu-libc' and omit the object files,

    52

   it is simpler to just do this in the source for each such file.  */

    53

    54

#define GETOPT_INTERFACE_VERSION 2

    55

#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2

    56

# include <gnu-versions.h>

    57

# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION

    58

#  define ELIDE_CODE

    59

# endif

    60

#endif

    61

    62

#ifndef ELIDE_CODE

    63

    64

    65

/* This needs to come after some library #include

    66

   to get __GNU_LIBRARY__ defined.  */

    67

#ifdef  __GNU_LIBRARY__

    68

/* Don't include stdlib.h for non-GNU C libraries because some of them

    69

   contain conflicting prototypes for getopt.  */

    70

# include <stdlib.h>

    71

# include <unistd.h>

    72

#endif  /* GNU C library.  */

    73

    74

#ifdef VMS

    75

# include <unixlib.h>

    76

# if HAVE_STRING_H - 0

    77

#  include <string.h>

    78

# endif

    79

#endif

    80

    81

#ifndef _

    82

/* This is for other GNU distributions with internationalized messages.  */

    83

# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC

    84

#  include <libintl.h>

    85

#  ifndef _

    86

#   define _(msgid)     gettext (msgid)

    87

#  endif

    88

# else

    89

#  define _(msgid)      (msgid)

    90

# endif

    91

# if defined _LIBC && defined USE_IN_LIBIO

    92

#  include <wchar.h>

    93

# endif

    94

#endif

    95

    96

/* This version of `getopt' appears to the caller like standard Unix `getopt'

    97

   but it behaves differently for the user, since it allows the user

    98

   to intersperse the options with the other arguments.

    99

   100

   As `getopt' works, it permutes the elements of ARGV so that,

   101

   when it is done, all the options precede everything else.  Thus

   102

   all application programs are extended to handle flexible argument order.

   103

   104

   Setting the environment variable POSIXLY_CORRECT disables permutation.

   105

   Then the behavior is completely standard.

   106

   107

   GNU application programs can use a third alternative mode in which

   108

   they can distinguish the relative order of options and other arguments.  */

   109

   110

#include "getopt.h"

   111

   112

/* For communication from `getopt' to the caller.

   113

   When `getopt' finds an option that takes an argument,

   114

   the argument value is returned here.

   115

   Also, when `ordering' is RETURN_IN_ORDER,

   116

   each non-option ARGV-element is returned here.  */

   117

   118

char *optarg;

   119

   120

/* Index in ARGV of the next element to be scanned.

   121

   This is used for communication to and from the caller

   122

   and for communication between successive calls to `getopt'.

   123

   124

   On entry to `getopt', zero means this is the first call; initialize.

   125

   126

   When `getopt' returns -1, this is the index of the first of the

   127

   non-option elements that the caller should itself scan.

   128

   129

   Otherwise, `optind' communicates from one call to the next

   130

   how much of ARGV has been scanned so far.  */

   131

   132

/* 1003.2 says this must be 1 before any call.  */

   133

int optind = 1;

   134

   135

/* Formerly, initialization of getopt depended on optind==0, which

   136

   causes problems with re-calling getopt as programs generally don't

   137

   know that. */

   138

   139

int __getopt_initialized;

   140

   141

/* The next char to be scanned in the option-element

   142

   in which the last option character we returned was found.

   143

   This allows us to pick up the scan where we left off.

   144

   145

   If this is zero, or a null string, it means resume the scan

   146

   by advancing to the next ARGV-element.  */

   147

   148

static char *nextchar;

   149

   150

/* Callers store zero here to inhibit the error message

   151

   for unrecognized options.  */

   152

   153

int opterr = 1;

   154

   155

/* Set to an option character which was unrecognized.

   156

   This must be initialized on some systems to avoid linking in the

   157

   system's own getopt implementation.  */

   158

   159

int optopt = '?';

   160

   161

/* Describe how to deal with options that follow non-option ARGV-elements.

   162

   163

   If the caller did not specify anything,

   164

   the default is REQUIRE_ORDER if the environment variable

   165

   POSIXLY_CORRECT is defined, PERMUTE otherwise.

   166

   167

   REQUIRE_ORDER means don't recognize them as options;

   168

   stop option processing when the first non-option is seen.

   169

   This is what Unix does.

   170

   This mode of operation is selected by either setting the environment

   171

   variable POSIXLY_CORRECT, or using `+' as the first character

   172

   of the list of option characters.

   173

   174

   PERMUTE is the default.  We permute the contents of ARGV as we scan,

   175

   so that eventually all the non-options are at the end.  This allows options

   176

   to be given in any order, even with programs that were not written to

   177

   expect this.

   178

   179

   RETURN_IN_ORDER is an option available to programs that were written

   180

   to expect options and other ARGV-elements in any order and that care about

   181

   the ordering of the two.  We describe each non-option ARGV-element

   182

   as if it were the argument of an option with character code 1.

   183

   Using `-' as the first character of the list of option characters

   184

   selects this mode of operation.

   185

   186

   The special argument `--' forces an end of option-scanning regardless

   187

   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only

   188

   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */

   189

   190

static enum

   191

{

   192

  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER

   193

} ordering;

   194

   195

/* Value of POSIXLY_CORRECT environment variable.  */

   196

static char *posixly_correct;

   197

   198

#ifdef  __GNU_LIBRARY__

   199

/* We want to avoid inclusion of string.h with non-GNU libraries

   200

   because there are many ways it can cause trouble.

   201

   On some systems, it contains special magic macros that don't work

   202

   in GCC.  */

   203

# include <string.h>

   204

# define my_index       strchr

   205

#else

   206

   207

# if HAVE_STRING_H || WIN32 /* Pete Wilson mod 7/28/02 */

   208

#  include <string.h>

   209

# else

   210

#  include <strings.h>

   211

# endif

   212

   213

/* Avoid depending on library functions or files

   214

   whose names are inconsistent.  */

   215

   216

#ifndef getenv

   217

extern char *getenv ();

   218

#endif

   219

   220

static char *

   221

my_index (str, chr)

   222

     const char *str;

   223

     int chr;

   224

{

   225

  while (*str)

   226

    {

   227

      if (*str == chr)

   228

        return (char *) str;

   229

      str++;

   230

    }

   231

  return 0;

   232

}

   233

   234

/* If using GCC, we can safely declare strlen this way.

   235

   If not using GCC, it is ok not to declare it.  */

   236

#ifdef __GNUC__

   237

/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.

   238

   That was relevant to code that was here before.  */

   239

# if (!defined __STDC__ || !__STDC__) && !defined strlen

   240

/* gcc with -traditional declares the built-in strlen to return int,

   241

   and has done so at least since version 2.4.5. -- rms.  */

   242

extern int strlen (const char *);

   243

# endif /* not __STDC__ */

   244

#endif /* __GNUC__ */

   245

   246

#endif /* not __GNU_LIBRARY__ */

   247

   248

/* Handle permutation of arguments.  */

   249

   250

/* Describe the part of ARGV that contains non-options that have

   251

   been skipped.  `first_nonopt' is the index in ARGV of the first of them;

   252

   `last_nonopt' is the index after the last of them.  */

   253

   254

static int first_nonopt;

   255

static int last_nonopt;

   256

   257

#ifdef _LIBC

   258

/* Stored original parameters.

   259

   XXX This is no good solution.  We should rather copy the args so

   260

   that we can compare them later.  But we must not use malloc(3).  */

   261

extern int __libc_argc;

   262

extern char **__libc_argv;

   263

   264

/* Bash 2.0 gives us an environment variable containing flags

   265

   indicating ARGV elements that should not be considered arguments.  */

   266

   267

# ifdef USE_NONOPTION_FLAGS

   268

/* Defined in getopt_init.c  */

   269

extern char *__getopt_nonoption_flags;

   270

   271

static int nonoption_flags_max_len;

   272

static int nonoption_flags_len;

   273

# endif

   274

   275

# ifdef USE_NONOPTION_FLAGS

   276

#  define SWAP_FLAGS(ch1, ch2) \

   277

  if (nonoption_flags_len > 0)                                                \

   278

    {                                                                         \

   279

      char __tmp = __getopt_nonoption_flags[ch1];                             \

   280

      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \

   281

      __getopt_nonoption_flags[ch2] = __tmp;                                  \

   282

    }

   283

# else

   284

#  define SWAP_FLAGS(ch1, ch2)

   285

# endif

   286

#else   /* !_LIBC */

   287

# define SWAP_FLAGS(ch1, ch2)

   288

#endif  /* _LIBC */

   289

   290

/* Exchange two adjacent subsequences of ARGV.

   291

   One subsequence is elements [first_nonopt,last_nonopt)

   292

   which contains all the non-options that have been skipped so far.

   293

   The other is elements [last_nonopt,optind), which contains all

   294

   the options processed since those non-options were skipped.

   295

   296

   `first_nonopt' and `last_nonopt' are relocated so that they describe

   297

   the new indices of the non-options in ARGV after they are moved.  */

   298

   299

#if defined __STDC__ && __STDC__

   300

static void exchange (char **);

   301

#endif

   302

   303

static void

   304

exchange (argv)

   305

     char **argv;

   306

{

   307

  int bottom = first_nonopt;

   308

  int middle = last_nonopt;

   309

  int top = optind;

   310

  char *tem;

   311

   312

  /* Exchange the shorter segment with the far end of the longer segment.

   313

     That puts the shorter segment into the right place.

   314

     It leaves the longer segment in the right place overall,

   315

     but it consists of two parts that need to be swapped next.  */

   316

   317

#if defined _LIBC && defined USE_NONOPTION_FLAGS

   318

  /* First make sure the handling of the `__getopt_nonoption_flags'

   319

     string can work normally.  Our top argument must be in the range

   320

     of the string.  */

   321

  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)

   322

    {

   323

      /* We must extend the array.  The user plays games with us and

   324

         presents new arguments.  */

   325

      char *new_str = malloc (top + 1);

   326

      if (new_str == NULL)

   327

        nonoption_flags_len = nonoption_flags_max_len = 0;

   328

      else

   329

        {

   330

          memset (__mempcpy (new_str, __getopt_nonoption_flags,

   331

                             nonoption_flags_max_len),

   332

                  '\0', top + 1 - nonoption_flags_max_len);

   333

          nonoption_flags_max_len = top + 1;

   334

          __getopt_nonoption_flags = new_str;

   335

        }

   336

    }

   337

#endif

   338

   339

  while (top > middle && middle > bottom)

   340

    {

   341

      if (top - middle > middle - bottom)

   342

        {

   343

          /* Bottom segment is the short one.  */

   344

          int len = middle - bottom;

   345

          register int i;

   346

   347

          /* Swap it with the top part of the top segment.  */

   348

          for (i = 0; i < len; i++)

   349

            {

   350

              tem = argv[bottom + i];

   351

              argv[bottom + i] = argv[top - (middle - bottom) + i];

   352

              argv[top - (middle - bottom) + i] = tem;

   353

              SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);

   354

            }

   355

          /* Exclude the moved bottom segment from further swapping.  */

   356

          top -= len;

   357

        }

   358

      else

   359

        {

   360

          /* Top segment is the short one.  */

   361

          int len = top - middle;

   362

          register int i;

   363

   364

          /* Swap it with the bottom part of the bottom segment.  */

   365

          for (i = 0; i < len; i++)

   366

            {

   367

              tem = argv[bottom + i];

   368

              argv[bottom + i] = argv[middle + i];

   369

              argv[middle + i] = tem;

   370

              SWAP_FLAGS (bottom + i, middle + i);

   371

            }

   372

          /* Exclude the moved top segment from further swapping.  */

   373

          bottom += len;

   374

        }

   375

    }

   376

   377

  /* Update records for the slots the non-options now occupy.  */

   378

   379

  first_nonopt += (optind - last_nonopt);

   380

  last_nonopt = optind;

   381

}

   382

   383

/* Initialize the internal data when the first call is made.  */

   384

   385

#if defined __STDC__ && __STDC__

   386

static const char *_getopt_initialize (int, char *const *, const char *);

   387

#endif

   388

static const char *

   389

_getopt_initialize (argc, argv, optstring)

   390

     int argc;

   391

     char *const *argv;

   392

     const char *optstring;

   393

{

   394

  /* Start processing options with ARGV-element 1 (since ARGV-element 0

   395

     is the program name); the sequence of previously skipped

   396

     non-option ARGV-elements is empty.  */

   397

   398

  first_nonopt = last_nonopt = optind;

   399

   400

  nextchar = NULL;

   401

   402

  posixly_correct = getenv ("POSIXLY_CORRECT");

   403

   404

  /* Determine how to handle the ordering of options and nonoptions.  */

   405

   406

  if (optstring[0] == '-')

   407

    {

   408

      ordering = RETURN_IN_ORDER;

   409

      ++optstring;

   410

    }

   411

  else if (optstring[0] == '+')

   412

    {

   413

      ordering = REQUIRE_ORDER;

   414

      ++optstring;

   415

    }

   416

  else if (posixly_correct != NULL)

   417

    ordering = REQUIRE_ORDER;

   418

  else

   419

    ordering = PERMUTE;

   420

   421

#if defined _LIBC && defined USE_NONOPTION_FLAGS

   422

  if (posixly_correct == NULL

   423

      && argc == __libc_argc && argv == __libc_argv)

   424

    {

   425

      if (nonoption_flags_max_len == 0)

   426

        {

   427

          if (__getopt_nonoption_flags == NULL

   428

              || __getopt_nonoption_flags[0] == '\0')

   429

            nonoption_flags_max_len = -1;

   430

          else

   431

            {

   432

              const char *orig_str = __getopt_nonoption_flags;

   433

              int len = nonoption_flags_max_len = strlen (orig_str);

   434

              if (nonoption_flags_max_len < argc)

   435

                nonoption_flags_max_len = argc;

   436

              __getopt_nonoption_flags =

   437

                (char *) malloc (nonoption_flags_max_len);

   438

              if (__getopt_nonoption_flags == NULL)

   439

                nonoption_flags_max_len = -1;

   440

              else

   441

                memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),

   442

                        '\0', nonoption_flags_max_len - len);

   443

            }

   444

        }

   445

      nonoption_flags_len = nonoption_flags_max_len;

   446

    }

   447

  else

   448

    nonoption_flags_len = 0;

   449

#endif

   450

   451

  return optstring;

   452

}

   453

   454

/* Scan elements of ARGV (whose length is ARGC) for option characters

   455

   given in OPTSTRING.

   456

   457

   If an element of ARGV starts with '-', and is not exactly "-" or "--",

   458

   then it is an option element.  The characters of this element

   459

   (aside from the initial '-') are option characters.  If `getopt'

   460

   is called repeatedly, it returns successively each of the option characters

   461

   from each of the option elements.

   462

   463

   If `getopt' finds another option character, it returns that character,

   464

   updating `optind' and `nextchar' so that the next call to `getopt' can

   465

   resume the scan with the following option character or ARGV-element.

   466

   467

   If there are no more option characters, `getopt' returns -1.

   468

   Then `optind' is the index in ARGV of the first ARGV-element

   469

   that is not an option.  (The ARGV-elements have been permuted

   470

   so that those that are not options now come last.)

   471

   472

   OPTSTRING is a string containing the legitimate option characters.

   473

   If an option character is seen that is not listed in OPTSTRING,

   474

   return '?' after printing an error message.  If you set `opterr' to

   475

   zero, the error message is suppressed but we still return '?'.

   476

   477

   If a char in OPTSTRING is followed by a colon, that means it wants an arg,

   478

   so the following text in the same ARGV-element, or the text of the following

   479

   ARGV-element, is returned in `optarg'.  Two colons mean an option that

   480

   wants an optional arg; if there is text in the current ARGV-element,

   481

   it is returned in `optarg', otherwise `optarg' is set to zero.

   482

   483

   If OPTSTRING starts with `-' or `+', it requests different methods of

   484

   handling the non-option ARGV-elements.

   485

   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.

   486

   487

   Long-named options begin with `--' instead of `-'.

   488

   Their names may be abbreviated as long as the abbreviation is unique

   489

   or is an exact match for some defined option.  If they have an

   490

   argument, it follows the option name in the same ARGV-element, separated

   491

   from the option name by a `=', or else the in next ARGV-element.

   492

   When `getopt' finds a long-named option, it returns 0 if that option's

   493

   `flag' field is nonzero, the value of the option's `val' field

   494

   if the `flag' field is zero.

   495

   496

   The elements of ARGV aren't really const, because we permute them.

   497

   But we pretend they're const in the prototype to be compatible

   498

   with other systems.

   499

   500

   LONGOPTS is a vector of `struct option' terminated by an

   501

   element containing a name which is zero.

   502

   503

   LONGIND returns the index in LONGOPT of the long-named option found.

   504

   It is only valid when a long-named option has been found by the most

   505

   recent call.

   506

   507

   If LONG_ONLY is nonzero, '-' as well as '--' can introduce

   508

   long-named options.  */

   509

   510

int

   511

_getopt_internal (argc, argv, optstring, longopts, longind, long_only)

   512

     int argc;

   513

     char *const *argv;

   514

     const char *optstring;

   515

     const struct option *longopts;

   516

     int *longind;

   517

     int long_only;

   518

{

   519

  int print_errors = opterr;

   520

  if (optstring[0] == ':')

   521

    print_errors = 0;

   522

   523

  if (argc < 1)

   524

    return -1;

   525

   526

  optarg = NULL;

   527

   528

  if (optind == 0 || !__getopt_initialized)

   529

    {

   530