~drizzle-trunk/drizzle/development : revision 1410.4.2

1

2

3

This program is free software; you can redistribute it and/or modify

4

it under the terms of the GNU General Public License as published by

5

the Free Software Foundation; version 2 of the License.

6

7

This program is distributed in the hope that it will be useful,

8

but WITHOUT ANY WARRANTY; without even the implied warranty of

9

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

10

GNU General Public License for more details.

11

12

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

13

along with this program; if not, write to the Free Software

14

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */

15

16

#include "config.h"

17

#include "drizzled/internal/my_sys.h"

18

#include <drizzled/gettext.h>

19

20

#include "drizzled/internal/m_string.h"

21

#include "drizzled/internal/my_sys.h"

22

#include "drizzled/error.h"

23

#include "drizzled/option.h"

24

25

#include <stdio.h>

26

#include <stdlib.h>

27

#include <errno.h>

28

#include <iostream>

29

#include <algorithm>

30

31

using namespace std;

32

namespace drizzled

33

{

34

35

typedef void (*init_func_p)(const struct my_option *option, char **variable,

36

int64_t value);

37

38

void default_reporter(enum loglevel level, const char *format, ...);

39

my_error_reporter my_getopt_error_reporter= &default_reporter;

40

41

static int findopt(char *optpat, uint32_t length,

42

const struct my_option **opt_res,

43

char **ffname);

44

static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err);

45

static uint64_t getopt_ull(char *arg, const struct my_option *optp,

46

int *err);

47

static size_t getopt_size(char *arg, const struct my_option *optp, int *err);

48

static double getopt_double(char *arg, const struct my_option *optp, int *err);

49

static void init_variables(const struct my_option *options,

50

init_func_p init_one_value);

51

static void init_one_value(const struct my_option *option, char **variable,

52

int64_t value);

53

static void fini_one_value(const struct my_option *option, char **variable,

54

int64_t value);

55

static int setval(const struct my_option *opts, char* *value, char *argument,

56

bool set_maximum_value);

57

static char *check_struct_option(char *cur_arg, char *key_name);

58

59

/*

60

The following three variables belong to same group and the number and

61

order of their arguments must correspond to each other.

62

*/

63

static const char *special_opt_prefix[]=

64

{"skip", "disable", "enable", "maximum", "loose", 0};

65

static const uint32_t special_opt_prefix_lengths[]=

66

{ 4, 7, 6, 7, 5, 0};

67

enum enum_special_opt

68

{ OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM, OPT_LOOSE};

69

70

char *disabled_my_option= (char*) "0";

71

72

/*

73

This is a flag that can be set in client programs. 1 means that

74

my_getopt will skip over options it does not know how to handle.

75

*/

76

77

bool my_getopt_skip_unknown= 0;

78

79

void default_reporter(enum loglevel level, const char *format, ...)

80

{

81

va_list args;

82

va_start(args, format);

83

if (level == WARNING_LEVEL)

84

fprintf(stderr, "%s", _("Warning: "));

85

else if (level == INFORMATION_LEVEL)

86

fprintf(stderr, "%s", _("Info: "));

87

vfprintf(stderr, format, args);

88

va_end(args);

89

fputc('\n', stderr);

90

fflush(stderr);

91

}

92

93

/*

94

function: handle_options

95

96

Sort options; put options first, until special end of options (--), or

97

until end of argv. Parse options; check that the given option matches with

98

one of the options in struct 'my_option', return error in case of ambiguous

99

or unknown option. Check that option was given an argument if it requires

100

one. Call function 'get_one_option()' once for each option.

101

*/

102

103

static getopt_get_addr_func getopt_get_addr;

104

105

int handle_options(int *argc, char ***argv,

106

const struct my_option *longopts,

107

my_get_one_option get_one_option)

108

{

109

uint32_t opt_found, argvpos= 0, length;

110

bool end_of_options= 0, must_be_var, set_maximum_value=false,

111

option_is_loose;

112

char **pos, **pos_end, *optend, *prev_found=NULL,

113

*opt_str, key_name[FN_REFLEN];

114

const struct my_option *optp;

115

char* *value;

116

int error, i;

117

118

/* handle_options() assumes arg0 (program name) always exists */

119

assert(argc && *argc >= 1);

120

assert(argv && *argv);

121

(*argc)--; /* Skip the program name */

122

(*argv)++; /* --- || ---- */

123

init_variables(longopts, init_one_value);

124

125

for (pos= *argv, pos_end=pos+ *argc; pos != pos_end ; pos++)

126

{

127

char **first= pos;

128

char *cur_arg= *pos;

129

if (cur_arg[0] == '-' && cur_arg[1] && !end_of_options) /* must be opt */

130

{

131

char *argument= 0;

132

must_be_var= 0;

133

set_maximum_value= 0;

134

option_is_loose= 0;

135

136

cur_arg++; /* skip '-' */

137

if (*cur_arg == '-' || *cur_arg == 'O') /* check for long option, */

138

{ /* --set-variable, or -O */

139

if (*cur_arg == 'O')

140

{

141

must_be_var= 1;

142

143

if (!(*++cur_arg)) /* If not -Ovar=# */

144

{

145

/* the argument must be in next argv */

146

if (!*++pos)

147

{

148

my_getopt_error_reporter(ERROR_LEVEL,

149

"%s: Option '-O' requires an argument",

150

internal::my_progname);

151

return EXIT_ARGUMENT_REQUIRED;

152

}

153

cur_arg= *pos;

154

(*argc)--;

155

}

156

}

157

else if (!getopt_compare_strings(cur_arg, "-set-variable", 13))

158

{

159

must_be_var= 1;

160

if (cur_arg[13] == '=')

161

{

162

cur_arg+= 14;

163

if (!*cur_arg)

164

{

165

my_getopt_error_reporter(ERROR_LEVEL,

166

"%s: Option '--set-variable' requires an argument",

167

internal::my_progname);

168

return EXIT_ARGUMENT_REQUIRED;

169

}

170

}

171

else if (cur_arg[14]) /* garbage, or another option. break out */

172

must_be_var= 0;

173

else

174

{

175

/* the argument must be in next argv */

176

if (!*++pos)

177

{

178

my_getopt_error_reporter(ERROR_LEVEL,

179

"%s: Option '--set-variable' requires an argument",

180

internal::my_progname);

181

return EXIT_ARGUMENT_REQUIRED;

182

}

183

cur_arg= *pos;

184

(*argc)--;

185

}

186

}

187

else if (!must_be_var)

188

{

189

if (!*++cur_arg) /* skip the double dash */

190

{

191

/* '--' means end of options, look no further */

192

end_of_options= 1;

193

(*argc)--;

194

continue;

195

}

196

}

197

opt_str= check_struct_option(cur_arg, key_name);

198

optend= strrchr(opt_str, '=');

199

if (optend != NULL)

200

{

201

length= (uint32_t) (optend - opt_str);

202

optend++;

203

}

204

else

205

{

206

length= static_cast<uint32_t>(strlen(opt_str));

207

optend= 0;

208

}

209

210

/*

211

Find first the right option. Return error in case of an ambiguous,

212

or unknown option

213

*/

214

optp= longopts;

215

if (!(opt_found= findopt(opt_str, length, &optp, &prev_found)))

216

{

217

/*

218

Didn't find any matching option. Let's see if someone called

219

option with a special option prefix

220

*/

221

if (!must_be_var)

222

{

223

if (optend)

224

must_be_var= 1; /* option is followed by an argument */

225

for (i= 0; special_opt_prefix[i]; i++)

226

{

227

if (!getopt_compare_strings(special_opt_prefix[i], opt_str,

228

special_opt_prefix_lengths[i]) &&

229

(opt_str[special_opt_prefix_lengths[i]] == '-' ||

230

opt_str[special_opt_prefix_lengths[i]] == '_'))

231

{

232

/*

233

We were called with a special prefix, we can reuse opt_found

234

*/

235

opt_str+= special_opt_prefix_lengths[i] + 1;

236

length-= special_opt_prefix_lengths[i] + 1;

237

if (i == OPT_LOOSE)

238

option_is_loose= 1;

239

if ((opt_found= findopt(opt_str, length, &optp, &prev_found)))

240

{

241

if (opt_found > 1)

242

{

243

my_getopt_error_reporter(ERROR_LEVEL,

244

"%s: ambiguous option '--%s-%s' (--%s-%s)",

245

internal::my_progname,

246

special_opt_prefix[i],

247

cur_arg, special_opt_prefix[i],

248

prev_found);

249

return EXIT_AMBIGUOUS_OPTION;

250

}

251

switch (i) {

252

case OPT_SKIP:

253

case OPT_DISABLE: /* fall through */

254

/*

255

double negation is actually enable again,

256

for example: --skip-option=0 -> option = true

257

*/

258

optend= (optend && *optend == '0' && !(*(optend + 1))) ?

259

(char*) "1" : disabled_my_option;

260

break;

261

case OPT_ENABLE:

262

optend= (optend && *optend == '0' && !(*(optend + 1))) ?

263

disabled_my_option : (char*) "1";

264

break;

265

case OPT_MAXIMUM:

266

set_maximum_value= true;

267

must_be_var= true;

268

break;

269

}

270

break; /* break from the inner loop, main loop continues */

271

}

272

i= -1; /* restart the loop */

273

}

274

}

275

}

276

if (!opt_found)

277

{

278

if (my_getopt_skip_unknown)

279

{

280

/*

281

preserve all the components of this unknown option, this may

282

occurr when the user provides options like: "-O foo" or

283

"--set-variable foo" (note that theres a space in there)

284

Generally, these kind of options are to be avoided

285

*/

286

do {

287

(*argv)[argvpos++]= *first++;

288

} while (first <= pos);

289

continue;

290

}

291

if (must_be_var)

292

{

293

my_getopt_error_reporter(option_is_loose ?

294

WARNING_LEVEL : ERROR_LEVEL,

295

"%s: unknown variable '%s'",

296

internal::my_progname, cur_arg);

297

if (!option_is_loose)

298

return EXIT_UNKNOWN_VARIABLE;

299

}

300

else

301

{

302

my_getopt_error_reporter(option_is_loose ?

303

WARNING_LEVEL : ERROR_LEVEL,

304

"%s: unknown option '--%s'",

305

internal::my_progname, cur_arg);

306

if (!option_is_loose)

307

return EXIT_UNKNOWN_OPTION;

308

}

309

if (option_is_loose)

310

{

311

(*argc)--;

312

continue;

313

}

314

}

315

}

316

if (opt_found > 1)

317

{

318

if (must_be_var)

319

{

320

my_getopt_error_reporter(ERROR_LEVEL,

321

"%s: variable prefix '%s' is not unique",

322

internal::my_progname, opt_str);

323

return EXIT_VAR_PREFIX_NOT_UNIQUE;

324

}

325

else

326

{

327

my_getopt_error_reporter(ERROR_LEVEL,

328

"%s: ambiguous option '--%s' (%s, %s)",

329

internal::my_progname, opt_str, prev_found,

330

optp->name);

331

return EXIT_AMBIGUOUS_OPTION;

332

}

333

}

334

if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)

335

{

336

fprintf(stderr,

337

_("%s: %s: Option '%s' used, but is disabled\n"),

338

internal::my_progname,

339

option_is_loose ? _("WARNING") : _("ERROR"), opt_str);

340

if (option_is_loose)

341

{

342

(*argc)--;

343

continue;

344

}

345

return EXIT_OPTION_DISABLED;

346

}

347

if (must_be_var && (optp->var_type & GET_TYPE_MASK) == GET_NO_ARG)

348

{

349

my_getopt_error_reporter(ERROR_LEVEL,

350

"%s: option '%s' cannot take an argument",

351

internal::my_progname, optp->name);

352

return EXIT_NO_ARGUMENT_ALLOWED;

353

}

354

value= optp->var_type & GET_ASK_ADDR ?

355

(*getopt_get_addr)(key_name, (uint32_t) strlen(key_name), optp) : optp->value;

356

357

if (optp->arg_type == NO_ARG)

358

{

359

if (optend && (optp->var_type & GET_TYPE_MASK) != GET_BOOL)

360

{

361

my_getopt_error_reporter(ERROR_LEVEL,

362

"%s: option '--%s' cannot take an argument",

363

internal::my_progname, optp->name);

364

return EXIT_NO_ARGUMENT_ALLOWED;

365

}

366

if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL)

367

{

368

/*

369

Set bool to 1 if no argument or if the user has used

370

--enable-'option-name'.

371

*optend was set to '0' if one used --disable-option

372

*/

373

(*argc)--;

374

if (!optend || *optend == '1' ||

375

!my_strcasecmp(&my_charset_utf8_general_ci, optend, "true"))

376

*((bool*) value)= (bool) 1;

377

else if (*optend == '0' ||

378

!my_strcasecmp(&my_charset_utf8_general_ci, optend, "false"))

379

*((bool*) value)= (bool) 0;

380

else

381

{

382

my_getopt_error_reporter(WARNING_LEVEL,

383

"%s: ignoring option '--%s' due to "

384

"invalid value '%s'",

385

internal::my_progname,

386

optp->name, optend);

387

continue;

388

}

389

error= get_one_option(optp->id, optp, *((bool*) value) ?

390

(char*) "1" : disabled_my_option);

391

if (error != 0)

392

return error;

393

else

394

continue;

395

}

396

argument= optend;

397

}

398

else if (optp->arg_type == OPT_ARG &&

399

(optp->var_type & GET_TYPE_MASK) == GET_BOOL)

400

{

401

if (optend == disabled_my_option)

402

*((bool*) value)= (bool) 0;

403

else

404

{

405

if (!optend) /* No argument -> enable option */

406

*((bool*) value)= (bool) 1;

407

else

408

argument= optend;

409

}

410

}

411

else if (optp->arg_type == REQUIRED_ARG && !optend)

412

{

413

/* Check if there are more arguments after this one */

414

if (!*++pos)

415

{

416

my_getopt_error_reporter(ERROR_LEVEL,

417

"%s: option '--%s' requires an argument",

418

internal::my_progname, optp->name);

419

return EXIT_ARGUMENT_REQUIRED;

420

}

421

argument= *pos;

422

(*argc)--;

423

}

424

else

425

argument= optend;

426

}

427

else /* must be short option */

428

{

429

for (optend= cur_arg; *optend; optend++)

430

{

431

opt_found= 0;

432

for (optp= longopts; optp->id; optp++)

433

{

434

if (optp->id == (int) (unsigned char) *optend)

435

{

436

/* Option recognized. Find next what to do with it */

437

opt_found= 1;

438

if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)

439

{

440

fprintf(stderr,

441

_("%s: ERROR: Option '-%c' used, but is disabled\n"),

442

internal::my_progname, optp->id);

443

return EXIT_OPTION_DISABLED;

444

}

445

if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL &&

446

optp->arg_type == NO_ARG)

447

{

448

*((bool*) optp->value)= (bool) 1;

449

error= get_one_option(optp->id, optp, argument);

450

if (error != 0)

451

return error;

452

else

453

continue;

454

455

}

456

else if (optp->arg_type == REQUIRED_ARG ||

457

optp->arg_type == OPT_ARG)

458

{

459

if (*(optend + 1))

460

{

461

/* The rest of the option is option argument */

462

argument= optend + 1;

463

/* This is in effect a jump out of the outer loop */

464

optend= (char*) " ";

465

}

466

else

467

{

468

if (optp->arg_type == OPT_ARG)

469

{

470

if (optp->var_type == GET_BOOL)

471

*((bool*) optp->value)= (bool) 1;

472

error= get_one_option(optp->id, optp, argument);

473

if (error != 0)

474

return error;

475

else

476

continue;

477

}

478

/* Check if there are more arguments after this one */

479

if (!pos[1])

480

{

481

my_getopt_error_reporter(ERROR_LEVEL,

482

"%s: option '-%c' requires "

483

"an argument",

484

internal::my_progname, optp->id);

485

return EXIT_ARGUMENT_REQUIRED;

486

}

487

argument= *++pos;

488

(*argc)--;

489

/* the other loop will break, because *optend + 1 == 0 */

490

}

491

}

492

if ((error= setval(optp, optp->value, argument,

493

set_maximum_value)))

494

{

495

my_getopt_error_reporter(ERROR_LEVEL,

496

"%s: Error while setting value '%s' "

497

"to '%s'",

498

internal::my_progname,

499

argument, optp->name);

500

return error;

501

}

502

error= get_one_option(optp->id, optp, argument);

503

if (error != 0)

504

return error;

505

else

506

break;

507

}

508

}

509

if (!opt_found)

510

{

511

my_getopt_error_reporter(ERROR_LEVEL,

512

"%s: unknown option '-%c'",

513

internal::my_progname, *optend);

514

return EXIT_UNKNOWN_OPTION;

515

}

516

}

517

(*argc)--; /* option handled (short), decrease argument count */

518

continue;

519

}

520

if ((error= setval(optp, value, argument, set_maximum_value)))

521

{

522

my_getopt_error_reporter(ERROR_LEVEL,

523

"%s: Error while setting value '%s' to '%s'",

524

internal::my_progname, argument, optp->name);

525

return error;

526

}

527

error= get_one_option(optp->id, optp, argument);

528

if (error != 0)

529

return error;

530

531

(*argc)--; /* option handled (short or long), decrease argument count */

532

}

533

else /* non-option found */

534

(*argv)[argvpos++]= cur_arg;

535

}

536

/*

537

Destroy the first, already handled option, so that programs that look

538

for arguments in 'argv', without checking 'argc', know when to stop.

539

Items in argv, before the destroyed one, are all non-option -arguments

540

to the program, yet to be (possibly) handled.

541

*/

542

(*argv)[argvpos]= 0;

543

return 0;

544

}

545

546

547

/*

548

function: check_struct_option

549

550

Arguments: Current argument under processing from argv and a variable

551

where to store the possible key name.

552

553

Return value: In case option is a struct option, returns a pointer to

554

the current argument at the position where the struct option (key_name)

555

ends, the next character after the dot. In case argument is not a struct

556

option, returns a pointer to the argument.

557

558

key_name will hold the name of the key, or 0 if not found.

559

*/

560

561

static char *check_struct_option(char *cur_arg, char *key_name)

562

{

563

char *ptr, *end;

564

565

ptr= strrchr(cur_arg + 1, '.'); /* Skip the first character */

566

end= strrchr(cur_arg, '=');

567

568

/*

569

If the first dot is after an equal sign, then it is part

570

of a variable value and the option is not a struct option.

571

Also, if the last character in the string before the ending

572

NULL, or the character right before equal sign is the first

573

dot found, the option is not a struct option.

574

*/

575

if ((ptr != NULL) && (end != NULL) && (end - ptr > 1))

576

{

577

uint32_t len= (uint32_t) (ptr - cur_arg);

578

set_if_smaller(len, (uint32_t)FN_REFLEN-1);

579

strncpy(key_name, cur_arg, len);

580

return ++ptr;

581

}

582

key_name[0]= 0;

583

return cur_arg;

584

}

585

586

/*

587

function: setval

588

589

Arguments: opts, argument

590

Will set the option value to given value

591

*/

592

593

static int setval(const struct my_option *opts, char **value, char *argument,

594

bool set_maximum_value)

595

{

596

int err= 0;

597

598

if (value && argument)

599

{

600

char* *result_pos= ((set_maximum_value) ?

601

opts->u_max_value : value);

602

603

if (!result_pos)

604

return EXIT_NO_PTR_TO_VARIABLE;

605

606

switch ((opts->var_type & GET_TYPE_MASK)) {

607

case GET_BOOL: /* If argument differs from 0, enable option, else disable */

608

*((bool*) result_pos)= (bool) atoi(argument) != 0;

609

break;

610

case GET_INT:

611

*((int32_t*) result_pos)= (int) getopt_ll(argument, opts, &err);

612

break;

613

case GET_UINT:

614

case GET_UINT32:

615

*((uint32_t*) result_pos)= (uint32_t) getopt_ull(argument, opts, &err);

616

break;

617

case GET_ULONG_IS_FAIL:

618

*((ulong*) result_pos)= (ulong) getopt_ull(argument, opts, &err);

619

break;

620

case GET_LONG:

621

*((long*) result_pos)= (long) getopt_ll(argument, opts, &err);

622

break;

623

case GET_LL:

624

*((int64_t*) result_pos)= getopt_ll(argument, opts, &err);

625

break;

626

case GET_ULL:

627

case GET_UINT64:

628

*((uint64_t*) result_pos)= getopt_ull(argument, opts, &err);

629

break;

630

case GET_SIZE:

631

*((size_t*) result_pos)= getopt_size(argument, opts, &err);

632

break;

633

case GET_DOUBLE:

634

*((double*) result_pos)= getopt_double(argument, opts, &err);

635

break;

636

case GET_STR:

637

*((char**) result_pos)= argument;

638

break;

639

case GET_STR_ALLOC:

640

if ((*((char**) result_pos)))

641

free((*(char**) result_pos));

642

if (!(*((char**) result_pos)= strdup(argument)))

643

return EXIT_OUT_OF_MEMORY;

644

break;

645

case GET_ENUM:

646

if (((*(int*)result_pos)= find_type(argument, opts->typelib, 2) - 1) < 0)

647

return EXIT_ARGUMENT_INVALID;

648

break;

649

case GET_SET:

650

*((uint64_t*)result_pos)= find_typeset(argument, opts->typelib, &err);

651

if (err)

652

return EXIT_ARGUMENT_INVALID;

653

break;

654

default: /* dummy default to avoid compiler warnings */

655

break;

656

}

657

if (err)

658

return EXIT_UNKNOWN_SUFFIX;

659

}

660

return 0;

661

}

662

663

664

/*

665

Find option

666

667

SYNOPSIS

668

findopt()

669

optpat Prefix of option to find (with - or _)

670

length Length of optpat

671

opt_res Options

672

ffname Place for pointer to first found name

673

674

IMPLEMENTATION

675

Go through all options in the my_option struct. Return number

676

of options found that match the pattern and in the argument

677

list the option found, if any. In case of ambiguous option, store

678

the name in ffname argument

679

680

RETURN

681

0 No matching options

682

# Number of matching options

683

ffname points to first matching option

684

*/

685

686

static int findopt(char *optpat, uint32_t length,

687

const struct my_option **opt_res,

688

char **ffname)

689

{

690

uint32_t count;

691

struct option *opt= (struct option *) *opt_res;

692

693

for (count= 0; opt->name; opt++)

694

{

695

if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */

696

{

697

(*opt_res)= opt;

698

if (!opt->name[length]) /* Exact match */

699

return 1;

700

if (!count)

701

{

702

count= 1;

703

*ffname= (char *) opt->name; /* We only need to know one prev */

704

}

705

else if (strcmp(*ffname, opt->name))

706

{

707

/*

708

The above test is to not count same option twice

709

(see mysql.cc, option "help")

710

*/

711

count++;

712

}

713

}

714

}

715

return count;

716

}

717

718

719

/*

720

function: compare_strings

721

722

Works like strncmp, other than 1.) considers '-' and '_' the same.

723

2.) Returns -1 if strings differ, 0 if they are equal

724

*/

725

726

bool getopt_compare_strings(register const char *s, register const char *t,

727

uint32_t length)

728

{

729

char const *end= s + length;

730

for (;s != end ; s++, t++)

731

{

732

if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))

733

return 1;

734

}

735

return 0;

736

}

737

738

/*

739

function: eval_num_suffix

740

741

Transforms a number with a suffix to real number. Suffix can

742

be k|K for kilo, m|M for mega or g|G for giga.

743

*/

744

745

static int64_t eval_num_suffix(char *argument, int *error, char *option_name)

746

{

747

char *endchar;

748

int64_t num;

749

750

*error= 0;

751

errno= 0;

752

num= strtoll(argument, &endchar, 10);

753

if (errno == ERANGE)

754

{

755

my_getopt_error_reporter(ERROR_LEVEL,

756

"Incorrect integer value: '%s'", argument);

757

*error= 1;

758

return 0;

759

}

760

if (*endchar == 'k' || *endchar == 'K')

761

num*= 1024L;

762

else if (*endchar == 'm' || *endchar == 'M')

763

num*= 1024L * 1024L;

764

else if (*endchar == 'g' || *endchar == 'G')

765

num*= 1024L * 1024L * 1024L;

766

else if (*endchar)

767

{

768

fprintf(stderr,

769

_("Unknown suffix '%c' used for variable '%s' (value '%s')\n"),

770

*endchar, option_name, argument);

771

*error= 1;

772

return 0;

773

}

774

return num;

775

}

776

777

/*

778

function: getopt_ll

779

780

Evaluates and returns the value that user gave as an argument

781

to a variable. Recognizes (case insensitive) K as KILO, M as MEGA

782

and G as GIGA bytes. Some values must be in certain blocks, as

783

defined in the given option struct, this function will check

784

that those values are honored.

785

In case of an error, set error value in *err.

786

*/

787

788

static int64_t getopt_ll(char *arg, const struct option *optp, int *err)

789

{

790

int64_t num=eval_num_suffix(arg, err, (char*) optp->name);

791

return getopt_ll_limit_value(num, optp, NULL);

792

}

793

794

/*

795

function: getopt_ll_limit_value

796

797

Applies min/max/block_size to a numeric value of an option.

798

Returns "fixed" value.

799

*/

800

801

int64_t getopt_ll_limit_value(int64_t num, const struct option *optp,

802

bool *fix)

803

{

804

int64_t old= num;

805

bool adjusted= false;

806

char buf1[255], buf2[255];

807

uint64_t block_size= (optp->block_size ? (uint64_t) optp->block_size : 1L);

808

809

if (num > 0 && ((uint64_t) num > (uint64_t) optp->max_value) &&

810

optp->max_value) /* if max value is not set -> no upper limit */

811

{

812

num= (uint64_t) optp->max_value;

813

adjusted= true;

814

}

815

816

switch ((optp->var_type & GET_TYPE_MASK)) {

817

case GET_INT:

818

if (num > (int64_t) INT_MAX)

819

{

820

num= ((int64_t) INT_MAX);

821

adjusted= true;

822

}

823

break;

824

case GET_LONG:

825

if (num > (int64_t) INT32_MAX)

826

{

827

num= ((int64_t) INT32_MAX);

828

adjusted= true;

829

}

830

break;

831

default:

832

assert((optp->var_type & GET_TYPE_MASK) == GET_LL);

833

break;

834

}

835

836

num= ((num - optp->sub_size) / block_size);

837

num= (int64_t) (num * block_size);

838

839

if (num < optp->min_value)

840

{

841

num= optp->min_value;

842

adjusted= true;

843

}

844

845

if (fix)

846

*fix= adjusted;

847

else if (adjusted)

848

my_getopt_error_reporter(WARNING_LEVEL,

849

"option '%s': signed value %s adjusted to %s",

850

optp->name, internal::llstr(old, buf1), internal::llstr(num, buf2));

851

return num;

852

}

853

854

/*

855

function: getopt_ull

856

857

This is the same as getopt_ll, but is meant for uint64_t

858

values.

859

*/

860

861

static uint64_t getopt_ull(char *arg, const struct option *optp, int *err)

862

{

863

uint64_t num= eval_num_suffix(arg, err, (char*) optp->name);

864

return getopt_ull_limit_value(num, optp, NULL);

865

}

866

867

868

static size_t getopt_size(char *arg, const struct option *optp, int *err)

869

{

870

return (size_t)getopt_ull(arg, optp, err);

871

}

872

873

874

875

uint64_t getopt_ull_limit_value(uint64_t num, const struct option *optp,

876

bool *fix)

877

{

878

bool adjusted= false;

879

uint64_t old= num;

880

char buf1[255], buf2[255];

881

882

if ((uint64_t) num > (uint64_t) optp->max_value &&

883

optp->max_value) /* if max value is not set -> no upper limit */

884

{

885

num= (uint64_t) optp->max_value;

886

adjusted= true;

887

}

888

889

switch ((optp->var_type & GET_TYPE_MASK)) {

890

case GET_UINT:

891

if (num > (uint64_t) UINT_MAX)

892

{

893

num= ((uint64_t) UINT_MAX);

894

adjusted= true;

895

}

896

break;

897

case GET_UINT32:

898

case GET_ULONG_IS_FAIL:

899

if (num > (uint64_t) UINT32_MAX)

900

{

901

num= ((uint64_t) UINT32_MAX);

902

adjusted= true;

903

}

904

break;

905

case GET_SIZE:

906

if (num > (uint64_t) SIZE_MAX)

907

{

908

num= ((uint64_t) SIZE_MAX);

909

adjusted= true;

910

}

911

break;

912

default:

913

assert(((optp->var_type & GET_TYPE_MASK) == GET_ULL)

914

|| ((optp->var_type & GET_TYPE_MASK) == GET_UINT64));

915

break;

916

}

917

918

if (optp->block_size > 1)

919

{

920

num/= (uint64_t) optp->block_size;

921

num*= (uint64_t) optp->block_size;

922

}

923

924

if (num < (uint64_t) optp->min_value)

925

{

926

num= (uint64_t) optp->min_value;

927

adjusted= true;

928

}

929

930

if (fix)

931

*fix= adjusted;

932

else if (adjusted)

933

my_getopt_error_reporter(WARNING_LEVEL,

934

"option '%s': unsigned value %s adjusted to %s",

935

optp->name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));

936

937

return num;

938

}

939

940

941

/*

942

Get double value withing ranges

943

944

Evaluates and returns the value that user gave as an argument to a variable.

945

946

RETURN

947

decimal value of arg

948

949

In case of an error, prints an error message and sets *err to

950

EXIT_ARGUMENT_INVALID. Otherwise err is not touched

951

*/

952

953

static double getopt_double(char *arg, const struct option *optp, int *err)

954

{

955

double num;

956

int error;

957

char *end= arg + 1000; /* Big enough as *arg is \0 terminated */

958

num= internal::my_strtod(arg, &end, &error);

959

if (end[0] != 0 || error)

960

{

961

fprintf(stderr,

962

_("%s: ERROR: Invalid decimal value for option '%s'\n"),

963

internal::my_progname, optp->name);

964

*err= EXIT_ARGUMENT_INVALID;

965

return 0.0;

966

}

967

if (optp->max_value && num > (double) optp->max_value)

968

num= (double) optp->max_value;

969

return max(num, (double) optp->min_value);

970

}

971

972

/*

973

Init one value to it's default values

974

975

SYNOPSIS

976

init_one_value()

977

option Option to initialize

978

value Pointer to variable

979

*/

980

981

static void init_one_value(const struct option *option, char** variable,

982

int64_t value)

983

{

984

switch ((option->var_type & GET_TYPE_MASK)) {

985

case GET_BOOL:

986

*((bool*) variable)= (bool) value;

987

break;

988

case GET_INT:

989

*((int*) variable)= (int) value;

990

break;

991

case GET_UINT:

992

case GET_ENUM:

993

*((uint*) variable)= (uint32_t) value;

994

break;

995

case GET_LONG:

996

*((long*) variable)= (long) value;

997

break;

998

case GET_UINT32:

999

*((uint32_t*) variable)= (uint32_t) value;

1000

break;

1001

case GET_ULONG_IS_FAIL:

1002

*((ulong*) variable)= (ulong) value;

1003

break;

1004

case GET_LL:

1005

*((int64_t*) variable)= (int64_t) value;

1006

break;

1007

case GET_SIZE:

1008

*((size_t*) variable)= (size_t) value;

1009

break;

1010

case GET_ULL:

1011

case GET_SET:

1012

case GET_UINT64:

1013

*((uint64_t*) variable)= (uint64_t) value;

1014

break;

1015

case GET_DOUBLE:

1016

*((double*) variable)= (double) value;

1017

break;

1018

case GET_STR:

1019

/*

1020

Do not clear variable value if it has no default value.

1021

The default value may already be set.

1022

NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,

1023

so that the value has the same size as a pointer.

1024

*/

1025

if ((char*) (intptr_t) value)

1026

*((char**) variable)= (char*) (intptr_t) value;

1027

break;

1028

case GET_STR_ALLOC:

1029

/*

1030

Do not clear variable value if it has no default value.

1031

The default value may already be set.

1032

NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,

1033

so that the value has the same size as a pointer.

1034

*/

1035

if ((char*) (intptr_t) value)

1036

{

1037

free((*(char**) variable));

1038

char *tmpptr= strdup((char *) (intptr_t) value);

1039

if (tmpptr != NULL)

1040

*((char**) variable)= tmpptr;

1041

}

1042

break;

1043

default: /* dummy default to avoid compiler warnings */

1044

break;

1045

}

1046

return;

1047

}

1048

1049

1050

/*

1051

Init one value to it's default values

1052

1053

SYNOPSIS

1054

init_one_value()

1055

option Option to initialize

1056

value Pointer to variable

1057

*/

1058

1059

static void fini_one_value(const struct option *option, char **variable,

1060

int64_t)

1061

{

1062

switch ((option->var_type & GET_TYPE_MASK)) {

1063

case GET_STR_ALLOC:

1064

free((*(char**) variable));

1065

*((char**) variable)= NULL;

1066

break;

1067

default: /* dummy default to avoid compiler warnings */

1068

break;

1069

}

1070

return;

1071

}

1072

1073

1074

void my_cleanup_options(const struct option *options)

1075

{

1076

init_variables(options, fini_one_value);

1077

}

1078

1079

1080

/*

1081

initialize all variables to their default values

1082

1083

SYNOPSIS

1084

init_variables()

1085

options Array of options

1086

1087

NOTES

1088

We will initialize the value that is pointed to by options->value.

1089

If the value is of type GET_ASK_ADDR, we will also ask for the address

1090

for a value and initialize.

1091

*/

1092

1093

static void init_variables(const struct option *options,

1094

init_func_p init_one_value)

1095

{

1096

for (; options->name; options++)

1097

{

1098

char* *variable;

1099

/*

1100

We must set u_max_value first as for some variables

1101

options->u_max_value == options->value and in this case we want to

1102

set the value to default value.

1103

*/

1104

if (options->u_max_value)

1105

init_one_value(options, options->u_max_value, options->max_value);

1106

if (options->value)

1107

init_one_value(options, options->value, options->def_value);

1108

if (options->var_type & GET_ASK_ADDR &&

1109

(variable= (*getopt_get_addr)("", 0, options)))

1110

init_one_value(options, variable, options->def_value);

1111

}

1112

return;

1113

}

1114

1115

1116

/*

1117

function: my_print_options

1118

1119

Print help for all options and variables.

1120

*/

1121

1122

void my_print_help(const struct option *options)

1123

{

1124

uint32_t col, name_space= 22, comment_space= 57;

1125

const char *line_end;

1126

const struct option *optp;

1127

1128

for (optp= options; optp->id; optp++)

1129

{

1130

if (optp->id < 256)

1131

{

1132

printf(" -%c%s", optp->id, strlen(optp->name) ? ", " : " ");

1133

col= 6;

1134

}

1135

else

1136

{

1137

printf(" ");

1138

col= 2;

1139

}

1140

if (strlen(optp->name))

1141

{

1142

printf("--%s", optp->name);

1143

col+= 2 + (uint32_t) strlen(optp->name);

1144

if ((optp->var_type & GET_TYPE_MASK) == GET_STR ||

1145

(optp->var_type & GET_TYPE_MASK) == GET_STR_ALLOC)

1146

{

1147

printf("%s=name%s ", optp->arg_type == OPT_ARG ? "[" : "",

1148

optp->arg_type == OPT_ARG ? "]" : "");

1149

col+= (optp->arg_type == OPT_ARG) ? 8 : 6;

1150

}

1151

else if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||

1152

(optp->var_type & GET_TYPE_MASK) == GET_BOOL)

1153

{

1154

putchar(' ');

1155

col++;

1156

}

1157

else

1158

{

1159

printf("%s=#%s ", optp->arg_type == OPT_ARG ? "[" : "",

1160

optp->arg_type == OPT_ARG ? "]" : "");

1161

col+= (optp->arg_type == OPT_ARG) ? 5 : 3;

1162

}

1163

if (col > name_space && optp->comment && *optp->comment)

1164

{

1165

putchar('\n');

1166

col= 0;

1167

}

1168

}

1169

for (; col < name_space; col++)

1170

putchar(' ');

1171

if (optp->comment && *optp->comment)

1172

{

1173

const char *comment= _(optp->comment), *end= strchr(comment, '\0');

1174

1175

while ((uint32_t) (end - comment) > comment_space)

1176

{

1177

for (line_end= comment + comment_space; *line_end != ' '; line_end--)

1178

{}

1179

for (; comment != line_end; comment++)

1180

putchar(*comment);

1181

comment++; /* skip the space, as a newline will take it's place now */

1182

putchar('\n');

1183

for (col= 0; col < name_space; col++)

1184

putchar(' ');

1185

}

1186

printf("%s", comment);

1187

}

1188

putchar('\n');

1189

if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||

1190

(optp->var_type & GET_TYPE_MASK) == GET_BOOL)

1191

{

1192

if (optp->def_value != 0)

1193

{

1194

printf(_("%*s(Defaults to on; use --skip-%s to disable.)\n"), name_space, "", optp->name);

1195

}

1196

}

1197

}

1198

}

1199

1200

1201

/*

1202

function: my_print_options

1203

1204

Print variables.

1205

*/

1206

1207

void my_print_variables(const struct option *options)

1208

{

1209

uint32_t name_space= 34, length, nr;

1210

uint64_t bit, llvalue;

1211

char buff[255];

1212

const struct option *optp;

1213

1214

printf(_("\nVariables (--variable-name=value)\n"

1215

"and boolean options {false|true} Value (after reading options)\n"

1216

"--------------------------------- -----------------------------\n"));

1217

for (optp= options; optp->id; optp++)

1218

{

1219

char* *value= (optp->var_type & GET_ASK_ADDR ?

1220

(*getopt_get_addr)("", 0, optp) : optp->value);

1221

if (value)

1222

{

1223

printf("%s ", optp->name);

1224

length= (uint32_t) strlen(optp->name)+1;

1225

for (; length < name_space; length++)

1226

putchar(' ');

1227

switch ((optp->var_type & GET_TYPE_MASK)) {

1228

case GET_SET:

1229

if (!(llvalue= *(uint64_t*) value))

1230

printf("%s\n", _("(No default value)"));

1231

else

1232

for (nr= 0, bit= 1; llvalue && nr < optp->typelib->count; nr++, bit<<=1)

1233

{

1234

if (!(bit & llvalue))

1235

continue;

1236

llvalue&= ~bit;

1237

printf( llvalue ? "%s," : "%s\n", get_type(optp->typelib, nr));

1238

}

1239

break;

1240

case GET_ENUM:

1241

printf("%s\n", get_type(optp->typelib, *(uint*) value));

1242

break;

1243

case GET_STR:

1244

case GET_STR_ALLOC: /* fall through */

1245

printf("%s\n", *((char**) value) ? *((char**) value) :

1246

_("(No default value)"));

1247

break;

1248

case GET_BOOL:

1249

printf("%s\n", *((bool*) value) ? _("true") : _("false"));

1250

break;

1251

case GET_INT:

1252

printf("%d\n", *((int*) value));

1253

break;

1254

case GET_UINT:

1255

printf("%d\n", *((uint*) value));

1256

break;

1257

case GET_LONG:

1258

printf("%ld\n", *((long*) value));

1259

break;

1260

case GET_UINT32:

1261

printf("%u\n", *((uint32_t*) value));

1262

break;

1263

case GET_ULONG_IS_FAIL:

1264

printf("%lu\n", *((ulong*) value));

1265

break;

1266

case GET_SIZE:

1267

internal::int64_t2str((uint64_t)(*(size_t*)value), buff, 10);

1268

printf("%s\n", buff);

1269

break;

1270

case GET_LL:

1271

printf("%s\n", internal::llstr(*((int64_t*) value), buff));

1272

break;

1273

case GET_ULL:

1274

case GET_UINT64:

1275

internal::int64_t2str(*((uint64_t*) value), buff, 10);

1276

printf("%s\n", buff);

1277

break;

1278

case GET_DOUBLE:

1279

printf("%g\n", *(double*) value);

1280

break;

1281

default:

1282

printf(_("(Disabled)\n"));

1283

break;

1284

}

1285

}

1286

}

1287

}

1288

1289

} /* namespace drizzled */