~ubuntu-branches/debian/sid/feh/sid : revision 8

1

/* Getopt for GNU.

2

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

3

"Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu

4

before changing it!

5

6

7

Free Software Foundation, Inc.

8

9

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

10

modify it under the terms of the GNU Library General Public License as

11

published by the Free Software Foundation; either version 2 of the

12

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

13

14

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

15

but WITHOUT ANY WARRANTY; without even the implied warranty of

16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

17

Library General Public License for more details.

18

19

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

20

License along with the GNU C Library; see the file COPYING.LIB. If not,

21

write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

22

Boston, MA 02111-1307, USA. */

23

24

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

25

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

26

#ifndef _NO_PROTO

27

#define _NO_PROTO

28

#endif

29

30

#if !defined (__STDC__) || !__STDC__

31

/* This is a separate conditional since some stdc systems

32

reject `defined (const)'. */

33

#ifndef const

34

#define const

35

#endif

36

#endif

37

38

#include <stdio.h>

39

40

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

41

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

42

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

43

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

44

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

45

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

46

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

47

48

#define GETOPT_INTERFACE_VERSION 2

49

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

50

#include <gnu-versions.h>

51

#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION

52

#define ELIDE_CODE

53

#endif

54

#endif

55

56

#ifndef ELIDE_CODE

57

58

/* This needs to come after some library #include

59

to get __GNU_LIBRARY__ defined. */

60

#ifdef __GNU_LIBRARY__

61

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

62

contain conflicting prototypes for getopt. */

63

#include <stdlib.h>

64

#include <unistd.h>

65

#endif /* GNU C library. */

66

67

#ifdef VMS

68

#include <unixlib.h>

69

#if HAVE_STRING_H - 0

70

#include <string.h>

71

#endif

72

#endif

73

74

#ifndef _

75

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

76

When compiling libc, the _ macro is predefined. */

77

#ifdef HAVE_LIBINTL_H

78

# include <libintl.h>

79

# define _(msgid) gettext (msgid)

80

#else

81

# define _(msgid) (msgid)

82

#endif

83

#endif

84

85

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

86

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

87

to intersperse the options with the other arguments.

88

89

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

90

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

91

all application programs are extended to handle flexible argument order.

92

93

Setting the environment variable POSIXLY_CORRECT disables permutation.

94

Then the behavior is completely standard.

95

96

GNU application programs can use a third alternative mode in which

97

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

98

99

#include "getopt.h"

100

101

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

102

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

103

the argument value is returned here.

104

Also, when `ordering' is RETURN_IN_ORDER,

105

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

106

107

char *optarg = NULL;

108

109

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

110

This is used for communication to and from the caller

111

and for communication between successive calls to `getopt'.

112

113

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

114

115

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

116

non-option elements that the caller should itself scan.

117

118

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

119

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

120

121

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

122

int optind = 1;

123

124

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

125

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

126

know that. */

127

128

int __getopt_initialized = 0;

129

130

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

131

in which the last option character we returned was found.

132

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

133

134

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

135

by advancing to the next ARGV-element. */

136

137

static char *nextchar;

138

139

/* Callers store zero here to inhibit the error message

140

for unrecognized options. */

141

142

int opterr = 1;

143

144

/* Set to an option character which was unrecognized.

145

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

146

system's own getopt implementation. */

147

148

int optopt = '?';

149

150

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

151

152

If the caller did not specify anything,

153

the default is REQUIRE_ORDER if the environment variable

154

POSIXLY_CORRECT is defined, PERMUTE otherwise.

155

156

REQUIRE_ORDER means don't recognize them as options;

157

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

158

This is what Unix does.

159

This mode of operation is selected by either setting the environment

160

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

161

of the list of option characters.

162

163

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

164

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

165

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

166

expect this.

167

168

RETURN_IN_ORDER is an option available to programs that were written

169

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

170

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

171

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

172

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

173

selects this mode of operation.

174

175

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

176

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

177

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

178

179

static enum {

180

REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER

181

} ordering;

182

183

/* Value of POSIXLY_CORRECT environment variable. */

184

static char *posixly_correct;

185

186

#ifdef __GNU_LIBRARY__

187

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

188

because there are many ways it can cause trouble.

189

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

190

in GCC. */

191

#include <string.h>

192

#define my_index strchr

193

#else

194

195

/* Avoid depending on library functions or files

196

whose names are inconsistent. */

197

198

char *getenv();

199

200

static char *my_index(str, chr)

201

const char *str;

202

int chr;

203

{

204

while (*str) {

205

if (*str == chr)

206

return (char *) str;

207

str++;

208

}

209

return 0;

210

}

211

212

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

213

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

214

#ifdef __GNUC__

215

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

216

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

217

#if !defined (__STDC__) || !__STDC__

218

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

219

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

220

extern int strlen(const char *);

221

#endif /* not __STDC__ */

222

#endif /* __GNUC__ */

223

224

#endif /* not __GNU_LIBRARY__ */

225

226

/* Handle permutation of arguments. */

227

228

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

229

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

230

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

231

232

static int first_nonopt;

233

static int last_nonopt;

234

235

#ifdef _LIBC

236

/* Bash 2.0 gives us an environment variable containing flags

237

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

238

239

/* Defined in getopt_init.c */

240

extern char *__getopt_nonoption_flags;

241

242

static int nonoption_flags_max_len;

243

static int nonoption_flags_len;

244

245

static int original_argc;

246

static char *const *original_argv;

247

248

/* Make sure the environment variable bash 2.0 puts in the environment

249

is valid for the getopt call we must make sure that the ARGV passed

250

to getopt is that one passed to the process. */

251

static void

252

__attribute__ ((unused)) store_args_and_env(int argc, char *const *argv)

253

{

254

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

255

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

256

original_argc = argc;

257

original_argv = argv;

258

}

259

260

# ifdef text_set_element

261

text_set_element(__libc_subinit, store_args_and_env);

262

# endif /* text_set_element */

263

264

# define SWAP_FLAGS(ch1, ch2) \

265

if (nonoption_flags_len > 0) \

266

{ \

267

char __tmp = __getopt_nonoption_flags[ch1]; \

268

__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \

269

__getopt_nonoption_flags[ch2] = __tmp; \

270

}

271

#else /* !_LIBC */

272

# define SWAP_FLAGS(ch1, ch2)

273

#endif /* _LIBC */

274

275

/* Exchange two adjacent subsequences of ARGV.

276

One subsequence is elements [first_nonopt,last_nonopt)

277

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

278

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

279

the options processed since those non-options were skipped.

280

281

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

282

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

283

284

#if defined (__STDC__) && __STDC__

285

static void exchange(char **);

286

#endif

287

288

static void exchange(argv)

289

char **argv;

290

{

291

int bottom = first_nonopt;

292

int middle = last_nonopt;

293

int top = optind;

294

char *tem;

295

296

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

297

That puts the shorter segment into the right place. It leaves the

298

longer segment in the right place overall, but it consists of two parts

299

that need to be swapped next. */

300

301

#ifdef _LIBC

302

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

303

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

304

string. */

305

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

306

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

307

new arguments. */

308

char *new_str = malloc(top + 1);

309

310

if (new_str == NULL)

311

nonoption_flags_len = nonoption_flags_max_len = 0;

312

else {

313

memset(__mempcpy

314

(new_str, __getopt_nonoption_flags,

315

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

316

nonoption_flags_max_len = top + 1;

317

__getopt_nonoption_flags = new_str;

318

}

319

}

320

#endif

321

322

while (top > middle && middle > bottom) {

323

if (top - middle > middle - bottom) {

324

/* Bottom segment is the short one. */

325

int len = middle - bottom;

326

register int i;

327

328

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

329

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

330

tem = argv[bottom + i];

331

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

332

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

333

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

334

}

335

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

336

top -= len;

337

} else {

338

/* Top segment is the short one. */

339

int len = top - middle;

340

register int i;

341

342

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

343

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

344

tem = argv[bottom + i];

345

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

346

argv[middle + i] = tem;

347

SWAP_FLAGS(bottom + i, middle + i);

348

}

349

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

350

bottom += len;

351

}

352

}

353

354

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

355

356

first_nonopt += (optind - last_nonopt);

357

last_nonopt = optind;

358

}

359

360

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

361

362

#if defined (__STDC__) && __STDC__

363

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

364

#endif

365

static const char *_getopt_initialize(argc, argv, optstring)

366

int argc;

367

char *const *argv;

368

const char *optstring;

369

{

370

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

371

the program name); the sequence of previously skipped non-option

372

ARGV-elements is empty. */

373

374

first_nonopt = last_nonopt = optind;

375

376

nextchar = NULL;

377

378

posixly_correct = getenv("POSIXLY_CORRECT");

379

380

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

381

382

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

383

ordering = RETURN_IN_ORDER;

384

++optstring;

385

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

386

ordering = REQUIRE_ORDER;

387

++optstring;

388

} else if (posixly_correct != NULL)

389

ordering = REQUIRE_ORDER;

390

else

391

ordering = PERMUTE;

392

393

#ifdef _LIBC

394

if (posixly_correct == NULL && argc == original_argc && argv == original_argv) {

395

if (nonoption_flags_max_len == 0) {

396

if (__getopt_nonoption_flags == NULL || __getopt_nonoption_flags[0] == '\0')

397

nonoption_flags_max_len = -1;

398

else {

399

const char *orig_str = __getopt_nonoption_flags;

400

int len = nonoption_flags_max_len = strlen(orig_str);

401

402

if (nonoption_flags_max_len < argc)

403

nonoption_flags_max_len = argc;

404

__getopt_nonoption_flags = (char *)

405

malloc(nonoption_flags_max_len);

406

if (__getopt_nonoption_flags == NULL)

407

nonoption_flags_max_len = -1;

408

else

409

memset(__mempcpy

410

(__getopt_nonoption_flags,

411

orig_str, len), '\0', nonoption_flags_max_len - len);

412

}

413

}

414

nonoption_flags_len = nonoption_flags_max_len;

415

} else

416

nonoption_flags_len = 0;

417

#endif

418

419

return optstring;

420

}

421

422

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

423

given in OPTSTRING.

424

425

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

426

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

427

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

428

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

429

from each of the option elements.

430

431

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

432

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

433

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

434

435

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

436

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

437

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

438

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

439

440

OPTSTRING is a string containing the legitimate option characters.

441

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

442

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

443

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

444

445

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

446

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

447

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

448

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

449

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

450

451

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

452

handling the non-option ARGV-elements.

453

See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.

454

455

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

456

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

457

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

458

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

459

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

460

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

461

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

462

if the `flag' field is zero.

463

464

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

465

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

466

with other systems.

467

468

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

469

element containing a name which is zero.

470

471

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

472

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

473

recent call.

474

475

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

476

long-named options. */

477

478

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

479

int argc;

480

char *const *argv;

481

const char *optstring;

482

const struct option *longopts;

483

int *longind;

484

int long_only;

485

{

486

optarg = NULL;

487

488

if (optind == 0 || !__getopt_initialized) {

489

if (optind == 0)

490

optind = 1; /* Don't scan ARGV[0], the

491

program name. */

492

optstring = _getopt_initialize(argc, argv, optstring);

493

__getopt_initialized = 1;

494

}

495

496

/* Test whether ARGV[optind] points to a non-option argument. Either it

497

does not have option syntax, or there is an environment flag from the

498

shell indicating it is not an option. The later information is only

499

used when the used in the GNU libc. */

500

#ifdef _LIBC

501

#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \

502

|| (optind < nonoption_flags_len \

503

&& __getopt_nonoption_flags[optind] == '1'))

504

#else

505

#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')

506

#endif

507

508

if (nextchar == NULL || *nextchar == '\0') {

509

/* Advance to the next ARGV-element. */

510

511

/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been

512

moved back by the user (who may also have changed the arguments). */

513

if (last_nonopt > optind)

514

last_nonopt = optind;

515

if (first_nonopt > optind)

516

first_nonopt = optind;

517

518

if (ordering == PERMUTE) {

519

/* If we have just processed some options following some

520

non-options, exchange them so that the options come first. */

521

522

if (first_nonopt != last_nonopt && last_nonopt != optind)

523

exchange((char **) argv);

524

else if (last_nonopt != optind)

525

first_nonopt = optind;

526

527

/* Skip any additional non-options and extend the range of

528

non-options previously skipped. */

529

530

while (optind < argc && NONOPTION_P)

531

optind++;

532

last_nonopt = optind;

533

}

534

535

/* The special ARGV-element `--' means premature end of options. Skip

536

it like a null option, then exchange with previous non-options as if

537

it were an option, then skip everything else like a non-option. */

538

539

if (optind != argc && !strcmp(argv[optind], "--")) {

540

optind++;

541

542

if (first_nonopt != last_nonopt && last_nonopt != optind)

543

exchange((char **) argv);

544

else if (first_nonopt == last_nonopt)

545

first_nonopt = optind;

546

last_nonopt = argc;

547

548

optind = argc;

549

}

550

551

/* If we have done all the ARGV-elements, stop the scan and back over

552

any non-options that we skipped and permuted. */

553

554

if (optind == argc) {

555

/* Set the next-arg-index to point at the non-options that we

556

previously skipped, so the caller will digest them. */

557

if (first_nonopt != last_nonopt)

558

optind = first_nonopt;

559

return -1;

560

}

561

562

/* If we have come to a non-option and did not permute it, either stop

563

the scan or describe it to the caller and pass it by. */

564

565

if (NONOPTION_P) {

566

if (ordering == REQUIRE_ORDER)

567

return -1;

568

optarg = argv[optind++];

569

return 1;

570

}

571

572

/* We have found another option-ARGV-element. Skip the initial

573

punctuation. */

574

575

nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-'));

576

}

577

578

/* Decode the current option-ARGV-element. */

579

580

/* Check whether the ARGV-element is a long option.

581

582

If long_only and the ARGV-element has the form "-f", where f is a valid

583

short option, don't consider it an abbreviated form of a long option

584

that starts with f. Otherwise there would be no way to give the -f

585

short option.

586

587

On the other hand, if there's a long option "fubar" and the

588

ARGV-element is "-fu", do consider that an abbreviation of the long

589

option, just like "--fu", and not "-f" with arg "u".

590

591

This distinction seems to be the most useful approach. */

592

593

if (longopts != NULL && (argv[optind][1] == '-' || (long_only && (argv[optind][2]

594

|| !my_index(optstring, argv[optind]

595

[1]))))) {

596

char *nameend;

597

const struct option *p;

598

const struct option *pfound = NULL;

599

int exact = 0;

600

int ambig = 0;

601

int indfound = -1;

602

int option_index;

603

604

for (nameend = nextchar; *nameend && *nameend != '='; nameend++)

605

/* Do nothing. */ ;

606

607

/* Test all long options for either exact match or abbreviated matches.

608

*/

609

for (p = longopts, option_index = 0; p->name; p++, option_index++)

610

if (!strncmp(p->name, nextchar, nameend - nextchar)) {

611

if ((unsigned int) (nameend - nextchar) == (unsigned int) strlen(p->name)) {

612

/* Exact match found. */

613

pfound = p;

614

indfound = option_index;

615

exact = 1;

616

break;

617

} else if (pfound == NULL) {

618

/* First nonexact match found. */

619

pfound = p;

620

indfound = option_index;

621

} else

622

/* Second or later nonexact match found. */

623

ambig = 1;

624

}

625

626

if (ambig && !exact) {

627

if (opterr)

628

fprintf(stderr, _("%s: option `%s' is ambiguous\n"), argv[0], argv[optind]);

629

nextchar += strlen(nextchar);

630

optind++;

631

optopt = 0;

632

return '?';

633

}

634

635

if (pfound != NULL) {

636

option_index = indfound;

637

optind++;

638

if (*nameend) {

639

/* Don't test has_arg with >, because some C compilers don't

640

allow it to be used on enums. */

641

if (pfound->has_arg)

642

optarg = nameend + 1;

643

else {

644

if (opterr) {

645

if (argv[optind - 1][1] == '-')

646

/* --option */

647

fprintf(stderr,

648

_

649

("%s: option `--%s' doesn't allow an argument\n"),

650

argv[0], pfound->name);

651

else

652

/* +option or -option */

653

fprintf(stderr,

654

_

655

("%s: option `%c%s' doesn't allow an argument\n"),

656

argv[0], argv[optind - 1][0], pfound->name);

657

}

658

659

nextchar += strlen(nextchar);

660

661

optopt = pfound->val;

662

return '?';

663

}

664

} else if (pfound->has_arg == 1) {

665

if (optind < argc)

666

optarg = argv[optind++];

667

else {

668

if (opterr)

669

fprintf(stderr,

670

_

671

("%s: option `%s' requires an argument\n"),

672

argv[0], argv[optind - 1]);

673

nextchar += strlen(nextchar);

674

optopt = pfound->val;

675

return optstring[0] == ':' ? ':' : '?';

676

}

677

}

678

nextchar += strlen(nextchar);

679

if (longind != NULL)

680

*longind = option_index;

681

if (pfound->flag) {

682

*(pfound->flag) = pfound->val;

683

return 0;

684

}

685

return pfound->val;

686

}

687

688

/* Can't find it as a long option. If this is not getopt_long_only, or

689

the option starts with '--' or is not a valid short option, then

690

it's an error. Otherwise interpret it as a short option. */

691

if (!long_only || argv[optind][1] == '-' || my_index(optstring, *nextchar) == NULL) {

692

if (opterr) {

693

if (argv[optind][1] == '-')

694

/* --option */

695

fprintf(stderr, _("%s: unrecognized option `--%s'\n"), argv[0], nextchar);

696

else

697

/* +option or -option */

698

fprintf(stderr,

699

_

700

("%s: unrecognized option `%c%s'\n"),

701

argv[0], argv[optind][0], nextchar);

702

}

703

nextchar = (char *) "";

704

optind++;

705

optopt = 0;

706

return '?';

707

}

708

}

709

710

/* Look at and handle the next short option-character. */

711

712

{

713

char c = *nextchar++;

714

char *temp = my_index(optstring, c);

715

716

/* Increment `optind' when we start to process its last character. */

717

if (*nextchar == '\0')

718

++optind;

719

720

if (temp == NULL || c == ':') {

721

if (opterr) {

722

if (posixly_correct)

723

/* 1003.2 specifies the format of this message. */

724

fprintf(stderr, _("%s: illegal option -- %c\n"), argv[0], c);

725

else

726

fprintf(stderr, _("%s: invalid option -- %c\n"), argv[0], c);

727

}

728

optopt = c;

729

return '?';

730

}

731

/* Convenience. Treat POSIX -W foo same as long option --foo */

732

if (temp[0] == 'W' && temp[1] == ';') {

733

char *nameend;

734

const struct option *p;

735

const struct option *pfound = NULL;

736

int exact = 0;

737

int ambig = 0;

738

int indfound = 0;

739

int option_index;

740

741

/* This is an option that requires an argument. */

742

if (*nextchar != '\0') {

743

optarg = nextchar;

744

/* If we end this ARGV-element by taking the rest as an arg, we

745

must advance to the next element now. */

746

optind++;

747

} else if (optind == argc) {

748

if (opterr) {

749

/* 1003.2 specifies the format of this message. */

750

fprintf(stderr, _("%s: option requires an argument -- %c\n"), argv[0], c);

751

}

752

optopt = c;

753

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

754

c = ':';

755

else

756

c = '?';

757

return c;

758

} else

759

/* We already incremented `optind' once; increment it again when

760

taking next ARGV-elt as argument. */

761

optarg = argv[optind++];

762

763

/* optarg is now the argument, see if it's in the table of longopts.

764

*/

765

766

for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)

767

/* Do nothing. */ ;

768

769

/* Test all long options for either exact match or abbreviated

770

matches. */

771

for (p = longopts, option_index = 0; p->name; p++, option_index++)

772

if (!strncmp(p->name, nextchar, nameend - nextchar)) {

773

if ((unsigned int) (nameend - nextchar) == strlen(p->name)) {

774

/* Exact match found. */

775

pfound = p;

776

indfound = option_index;

777

exact = 1;

778

break;

779

} else if (pfound == NULL) {

780

/* First nonexact match found. */

781

pfound = p;

782

indfound = option_index;

783

} else

784

/* Second or later nonexact match found. */

785

ambig = 1;

786

}

787

if (ambig && !exact) {

788

if (opterr)

789

fprintf(stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0], argv[optind]);

790

nextchar += strlen(nextchar);

791

optind++;

792

return '?';

793

}

794

if (pfound != NULL) {

795

option_index = indfound;

796

if (*nameend) {

797

/* Don't test has_arg with >, because some C compilers don't

798

allow it to be used on enums. */

799

if (pfound->has_arg)

800

optarg = nameend + 1;

801

else {

802

if (opterr)

803

fprintf(stderr, _("\

804

%s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name);

805

806

nextchar += strlen(nextchar);

807

return '?';

808

}

809

} else if (pfound->has_arg == 1) {

810

if (optind < argc)

811

optarg = argv[optind++];

812

else {

813

if (opterr)

814

fprintf(stderr,

815

_

816

("%s: option `%s' requires an argument\n"),

817

argv[0], argv[optind - 1]);

818

nextchar += strlen(nextchar);

819

return optstring[0] == ':' ? ':' : '?';

820

}

821

}

822

nextchar += strlen(nextchar);

823

if (longind != NULL)

824

*longind = option_index;

825

if (pfound->flag) {

826

*(pfound->flag) = pfound->val;

827

return 0;

828

}

829

return pfound->val;

830

}

831

nextchar = NULL;

832

return 'W'; /* Let the application handle it.

833

*/

834

}

835

if (temp[1] == ':') {

836

if (temp[2] == ':') {

837

/* This is an option that accepts an argument optionally. */

838

if (*nextchar != '\0') {

839

optarg = nextchar;

840

optind++;

841

} else

842

optarg = NULL;

843

nextchar = NULL;

844

} else {

845

/* This is an option that requires an argument. */

846

if (*nextchar != '\0') {

847

optarg = nextchar;

848

/* If we end this ARGV-element by taking the rest as an arg,

849

we must advance to the next element now. */

850

optind++;

851

} else if (optind == argc) {

852

if (opterr) {

853

/* 1003.2 specifies the format of this message. */

854

fprintf(stderr,

855

_("%s: option requires an argument -- %c\n"), argv[0], c);

856

}

857

optopt = c;

858

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

859

c = ':';

860

else

861

c = '?';

862

} else

863

/* We already incremented `optind' once; increment it again

864

when taking next ARGV-elt as argument. */

865

optarg = argv[optind++];

866

nextchar = NULL;

867

}

868

}

869

return c;

870

}

871

}

872

873

int getopt(argc, argv, optstring)

874

int argc;

875

char *const *argv;

876

const char *optstring;

877

{

878

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

879

}

880

881

#endif /* Not ELIDE_CODE. */

882

883

#ifdef TEST

884

885

/* Compile with -DTEST to make an executable for use in testing

886

the above definition of `getopt'. */

887

888

int main(argc, argv)

889

int argc;

890

char **argv;

891

{

892

int c;

893

int digit_optind = 0;

894

895

while (1) {

896

int this_option_optind = optind ? optind : 1;

897

898

c = getopt(argc, argv, "abc:d:0123456789");

899

if (c == -1)

900

break;

901

902

switch (c) {

903

case '0':

904

case '1':

905

case '2':

906

case '3':

907

case '4':

908

case '5':

909

case '6':

910

case '7':

911

case '8':

912

case '9':

913

if (digit_optind != 0 && digit_optind != this_option_optind)

914

printf("digits occur in two different argv-elements.\n");

915

digit_optind = this_option_optind;

916

printf("option %c\n", c);

917

break;

918

919

case 'a':

920

printf("option a\n");

921

break;

922

923

case 'b':

924

printf("option b\n");

925

break;

926

927

case 'c':

928

printf("option c with value `%s'\n", optarg);

929

break;

930

931

case '?':

932

break;

933

934

default:

935

printf("?? getopt returned character code 0%o ??\n", c);

936

}

937

}

938

939

if (optind < argc) {

940

printf("non-option ARGV-elements: ");

941

while (optind < argc)

942

printf("%s ", argv[optind++]);

943

printf("\n");

944

}

945

946

exit(0);

947

}

948

949

#endif /* TEST */