util/argparse.c

   1 /* [argparse.c wk 17.06.97] Argument Parser for option handling
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
   3  *               2007 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26
  27 #include "util.h"
  28 #include "i18n.h"
  29
  30
  31 /*********************************
  32  * @Summary arg_parse
  33  *  #include <wk/lib.h>
  34  *
  35  *  typedef struct {
  36  *      char *argc;               pointer to argc (value subject to change)
  37  *      char ***argv;             pointer to argv (value subject to change)
  38  *      unsigned flags;           Global flags (DO NOT CHANGE)
  39  *      int err;                  print error about last option
  40  *                                1 = warning, 2 = abort
  41  *      int r_opt;                return option
  42  *      int r_type;               type of return value (0 = no argument found)
  43  *      union {
  44  *          int   ret_int;
  45  *          long  ret_long
  46  *          ulong ret_ulong;
  47  *          char *ret_str;
  48  *      } r;                      Return values
  49  *      struct {
  50  *          int idx;
  51  *          const char *last;
  52  *          void *aliases;
  53  *      } internal;               DO NOT CHANGE
  54  *  } ARGPARSE_ARGS;
  55  *
  56  *  typedef struct {
  57  *      int         short_opt;
  58  *      const char *long_opt;
  59  *      unsigned flags;
  60  *  } ARGPARSE_OPTS;
  61  *
  62  *  int arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts );
  63  *
  64  * @Description
  65  *  This is my replacement for getopt(). See the example for a typical usage.
  66  *  Global flags are:
  67  *     Bit 0 : Do not remove options form argv
  68  *     Bit 1 : Do not stop at last option but return other args
  69  *             with r_opt set to -1.
  70  *     Bit 2 : Assume options and real args are mixed.
  71  *     Bit 3 : Do not use -- to stop option processing.
  72  *     Bit 4 : Do not skip the first arg.
  73  *     Bit 5 : allow usage of long option with only one dash
  74  *     Bit 6 : ignore --version and --help
  75  *     all other bits must be set to zero, this value is modified by the
  76  *     function, so assume this is write only.
  77  *  Local flags (for each option):
  78  *     Bit 2-0 : 0 = does not take an argument
  79  *               1 = takes int argument
  80  *               2 = takes string argument
  81  *               3 = takes long argument
  82  *               4 = takes ulong argument
  83  *     Bit 3 : argument is optional (r_type will the be set to 0)
  84  *     Bit 4 : allow 0x etc. prefixed values.
  85  *     Bit 7 : this is a command and not an option
  86  *  You stop the option processing by setting opts to NULL, the function will
  87  *  then return 0.
  88  * @Return Value
  89  *   Returns the args.r_opt or 0 if ready
  90  *   r_opt may be -2/-7 to indicate an unknown option/command.
  91  * @See Also
  92  *   ArgExpand
  93  * @Notes
  94  *  You do not need to process the options 'h', '--help' or '--version'
  95  *  because this function includes standard help processing; but if you
  96  *  specify '-h', '--help' or '--version' you have to do it yourself.
  97  *  The option '--' stops argument processing; if bit 1 is set the function
  98  *  continues to return normal arguments.
  99  *  To process float args or unsigned args you must use a string args and do
 100  *  the conversion yourself.
 101  * @Example
 102  *
 103  *     ARGPARSE_OPTS opts[] = {
 104  *     { 'v', "verbose",   0 },
 105  *     { 'd', "debug",     0 },
 106  *     { 'o', "output",    2 },
 107  *     { 'c', "cross-ref", 2|8 },
 108  *     { 'm', "my-option", 1|8 },
 109  *     { 500, "have-no-short-option-for-this-long-option", 0 },
 110  *     {0} };
 111  *     ARGPARSE_ARGS pargs = { &argc, &argv, 0 }
 112  *
 113  *     while( ArgParse( &pargs, &opts) ) {
 114  *         switch( pargs.r_opt ) {
 115  *           case 'v': opt.verbose++; break;
 116  *           case 'd': opt.debug++; break;
 117  *           case 'o': opt.outfile = pargs.r.ret_str; break;
 118  *           case 'c': opt.crf = pargs.r_type? pargs.r.ret_str:"a.crf"; break;
 119  *           case 'm': opt.myopt = pargs.r_type? pargs.r.ret_int : 1; break;
 120  *           case 500: opt.a_long_one++;  break
 121  *           default : pargs.err = 1; break; -- force warning output --
 122  *         }
 123  *     }
 124  *     if( argc > 1 )
 125  *         log_fatal( "Too many args");
 126  *
 127  */
 128
 129 typedef struct alias_def_s *ALIAS_DEF;
 130 struct alias_def_s {
 131     ALIAS_DEF next;
 132     char *name;   /* malloced buffer with name, \0, value */
 133     const char *value; /* ptr into name */
 134 };
 135
 136 static int  set_opt_arg(ARGPARSE_ARGS *arg, unsigned flags, char *s);
 137 static void show_help(ARGPARSE_OPTS *opts, unsigned flags);
 138 static void show_version(void);
 139
 140 static void
 141 initialize( ARGPARSE_ARGS *arg, const char *filename, unsigned *lineno )
 142 {
 143     if( !(arg->flags & (1<<15)) ) { /* initialize this instance */
 144         arg->internal.idx = 0;
 145         arg->internal.last = NULL;
 146         arg->internal.inarg = 0;
 147         arg->internal.stopped = 0;
 148         arg->internal.aliases = NULL;
 149         arg->internal.cur_alias = NULL;
 150         arg->err = 0;
 151         arg->flags |= 1<<15; /* mark initialized */
 152         if( *arg->argc < 0 )
 153             log_bug("Invalid argument for ArgParse\n");
 154     }
 155
 156
 157     if( arg->err ) { /* last option was erroneous */
 158
 159         if( filename ) {
 160             if( arg->r_opt == -6 )
 161               log_error("%s:%u: argument not expected\n", filename, *lineno );
 162             else if( arg->r_opt == -5 )
 163               log_error("%s:%u: read error\n", filename, *lineno );
 164             else if( arg->r_opt == -4 )
 165               log_error("%s:%u: keyword too long\n", filename, *lineno );
 166             else if( arg->r_opt == -3 )
 167               log_error("%s:%u: missing argument\n", filename, *lineno );
 168             else if( arg->r_opt == -7 )
 169               log_error("%s:%u: invalid command\n", filename, *lineno );
 170             else if( arg->r_opt == -10 )
 171               log_error("%s:%u: invalid alias definition\n",filename,*lineno);
 172             else
 173               log_error("%s:%u: invalid option\n", filename, *lineno );
 174         }
 175         else {
 176             if( arg->r_opt == -3 )
 177               log_error("Missing argument for option \"%.50s\"\n",
 178                         arg->internal.last? arg->internal.last:"[??]" );
 179             else if( arg->r_opt == -6 )
 180               log_error("Option \"%.50s\" does not expect an argument\n",
 181                         arg->internal.last? arg->internal.last:"[??]" );
 182             else if( arg->r_opt == -7 )
 183               log_error("Invalid command \"%.50s\"\n",
 184                         arg->internal.last? arg->internal.last:"[??]" );
 185             else if( arg->r_opt == -8 )
 186               log_error("Option \"%.50s\" is ambiguous\n",
 187                         arg->internal.last? arg->internal.last:"[??]" );
 188             else if( arg->r_opt == -9 )
 189               log_error("Command \"%.50s\" is ambiguous\n",
 190                         arg->internal.last? arg->internal.last:"[??]" );
 191             else
 192               log_error("Invalid option \"%.50s\"\n",
 193                         arg->internal.last? arg->internal.last:"[??]" );
 194         }
 195         if( arg->err != 1 || arg->r_opt == -5 )
 196             exit(2);
 197         arg->err = 0;
 198     }
 199
 200     /* clearout the return value union */
 201     arg->r.ret_str = NULL;
 202     arg->r.ret_long= 0;
 203 }
 204
 205
 206 static void
 207 store_alias( ARGPARSE_ARGS *arg, char *name, char *value )
 208 {
 209     /* TODO: replace this dummy function with a rea one
 210      * and fix the probelms IRIX has with (ALIAS_DEV)arg..
 211      * used as lvalue
 212      */
 213 #if 0
 214     ALIAS_DEF a = xmalloc( sizeof *a );
 215     a->name = name;
 216     a->value = value;
 217     a->next = (ALIAS_DEF)arg->internal.aliases;
 218     (ALIAS_DEF)arg->internal.aliases = a;
 219 #endif
 220 }
 221
 222 /****************
 223  * Get options from a file.
 224  * Lines starting with '#' are comment lines.
 225  * Syntax is simply a keyword and the argument.
 226  * Valid keywords are all keywords from the long_opt list without
 227  * the leading dashes. The special keywords "help", "warranty" and "version"
 228  * are not valid here.
 229  * The special keyword "alias" may be used to store alias definitions,
 230  * which are later expanded like long options.
 231  * Caller must free returned strings.
 232  * If called with FP set to NULL command line args are parse instead.
 233  *
 234  * Q: Should we allow the syntax
 235  *     keyword = value
 236  *    and accept for boolean options a value of 1/0, yes/no or true/false?
 237  * Note: Abbreviation of options is here not allowed.
 238  */
 239 int
 240 optfile_parse( FILE *fp, const char *filename, unsigned *lineno,
 241                ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts)
 242 {
 243     int state, i, c;
 244     int idx=0;
 245     char keyword[100];
 246     char *buffer = NULL;
 247     size_t buflen = 0;
 248     int inverse=0;
 249     int in_alias=0;
 250
 251     if( !fp ) /* same as arg_parse() in this case */
 252         return arg_parse( arg, opts );
 253
 254     initialize( arg, filename, lineno );
 255
 256     /* find the next keyword */
 257     state = i = 0;
 258     for(;;) {
 259         c=getc(fp);
 260         if( c == '\n' || c== EOF ) {
 261             if( c != EOF )
 262                 ++*lineno;
 263             if( state == -1 )
 264                 break;
 265             else if( state == 2 ) {
 266                 keyword[i] = 0;
 267                 for(i=0; opts[i].short_opt; i++ )
 268                     if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
 269                         break;
 270                 idx = i;
 271                 arg->r_opt = opts[idx].short_opt;
 272                 if( inverse ) /* this does not have an effect, hmmm */
 273                     arg->r_opt = -arg->r_opt;
 274                 if( !opts[idx].short_opt )   /* unknown command/option */
 275                     arg->r_opt = (opts[idx].flags & 256)? -7:-2;
 276                 else if( !(opts[idx].flags & 7) ) /* does not take an arg */
 277                     arg->r_type = 0;           /* okay */
 278                 else if( (opts[idx].flags & 8) )  /* argument is optional */
 279                     arg->r_type = 0;           /* okay */
 280                 else                           /* required argument */
 281                     arg->r_opt = -3;           /* error */
 282                 break;
 283             }
 284             else if( state == 3 ) {            /* no argument found */
 285                 if( in_alias )
 286                     arg->r_opt = -3;           /* error */
 287                 else if( !(opts[idx].flags & 7) ) /* does not take an arg */
 288                     arg->r_type = 0;           /* okay */
 289                 else if( (opts[idx].flags & 8) )  /* no optional argument */
 290                     arg->r_type = 0;           /* okay */
 291                 else                           /* no required argument */
 292                     arg->r_opt = -3;           /* error */
 293                 break;
 294             }
 295             else if( state == 4 ) {     /* have an argument */
 296                 if( in_alias ) {
 297                     if( !buffer )
 298                         arg->r_opt = -6;
 299                     else {
 300                         char *p;
 301
 302                         buffer[i] = 0;
 303                         p = strpbrk( buffer, " \t" );
 304                         if( p ) {
 305                             *p++ = 0;
 306                             trim_spaces( p );
 307                         }
 308                         if( !p || !*p ) {
 309                             xfree( buffer );
 310                             arg->r_opt = -10;
 311                         }
 312                         else {
 313                             store_alias( arg, buffer, p );
 314                         }
 315                     }
 316                 }
 317                 else if( !(opts[idx].flags & 7) )  /* does not take an arg */
 318                     arg->r_opt = -6;        /* error */
 319                 else {
 320                     char *p;
 321                     if( !buffer ) {
 322                         keyword[i] = 0;
 323                         buffer = xstrdup(keyword);
 324                     }
 325                     else
 326                         buffer[i] = 0;
 327
 328                     trim_spaces( buffer );
 329                     p = buffer;
 330                     /* remove quotes if they totally enclose the
 331                        string, and do not occur within the string */
 332                     if( *p == '"' && p[strlen(p)-1]=='"') {
 333                         char *p2=p;
 334
 335                         while(*(++p2))
 336                           if(*p2=='"')
 337                             break;
 338
 339                         if(*p2=='"' && *(p2+1)=='\0') {
 340                           p[strlen(p)-1] = 0;
 341                           p++;
 342                         }
 343                     }
 344                     if( !set_opt_arg(arg, opts[idx].flags, p) )
 345                         xfree(buffer);
 346                 }
 347                 break;
 348             }
 349             else if( c == EOF ) {
 350                 if( ferror(fp) )
 351                     arg->r_opt = -5;   /* read error */
 352                 else
 353                     arg->r_opt = 0;    /* eof */
 354                 break;
 355             }
 356             state = 0;
 357             i = 0;
 358         }
 359         else if( state == -1 )
 360             ; /* skip */
 361         else if( !state && isspace(c) )
 362             ; /* skip leading white space */
 363         else if( !state && c == '#' )
 364             state = 1;  /* start of a comment */
 365         else if( state == 1 )
 366             ; /* skip comments */
 367         else if( state == 2 && isspace(c) ) {
 368             keyword[i] = 0;
 369             for(i=0; opts[i].short_opt; i++ )
 370                 if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
 371                     break;
 372             idx = i;
 373             arg->r_opt = opts[idx].short_opt;
 374             if( !opts[idx].short_opt ) {
 375                 if( !strcmp( keyword, "alias" ) ) {
 376                     in_alias = 1;
 377                     state = 3;
 378                 }
 379                 else {
 380                     arg->r_opt = (opts[idx].flags & 256)? -7:-2;
 381                     state = -1;        /* skip rest of line and leave */
 382                 }
 383             }
 384             else
 385                 state = 3;
 386         }
 387         else if( state == 3 ) { /* skip leading spaces of the argument */
 388             if( !isspace(c) ) {
 389                 i = 0;
 390                 keyword[i++] = c;
 391                 state = 4;
 392             }
 393         }
 394         else if( state == 4 ) { /* collect the argument */
 395             if( buffer ) {
 396                 if( i < buflen-1 )
 397                     buffer[i++] = c;
 398                 else {
 399                     buflen += 50;
 400                     buffer = xrealloc(buffer, buflen);
 401                     buffer[i++] = c;
 402                 }
 403             }
 404             else if( i < DIM(keyword)-1 )
 405                 keyword[i++] = c;
 406             else {
 407                 buflen = DIM(keyword)+50;
 408                 buffer = xmalloc(buflen);
 409                 memcpy(buffer, keyword, i);
 410                 buffer[i++] = c;
 411             }
 412         }
 413         else if( i >= DIM(keyword)-1 ) {
 414             arg->r_opt = -4;   /* keyword to long */
 415             state = -1;        /* skip rest of line and leave */
 416         }
 417         else {
 418             keyword[i++] = c;
 419             state = 2;
 420         }
 421     }
 422
 423     return arg->r_opt;
 424 }
 425
 426
 427
 428 static int
 429 find_long_option( ARGPARSE_ARGS *arg,
 430                   ARGPARSE_OPTS *opts, const char *keyword )
 431 {
 432     int i;
 433     size_t n;
 434
 435     /* Would be better if we can do a binary search, but it is not
 436        possible to reorder our option table because we would mess
 437        up our help strings - What we can do is: Build a nice option
 438        lookup table wehn this function is first invoked */
 439     if( !*keyword )
 440         return -1;
 441     for(i=0; opts[i].short_opt; i++ )
 442         if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
 443             return i;
 444 #if 0
 445     {
 446         ALIAS_DEF a;
 447         /* see whether it is an alias */
 448         for( a = args->internal.aliases; a; a = a->next ) {
 449             if( !strcmp( a->name, keyword) ) {
 450                 /* todo: must parse the alias here */
 451                 args->internal.cur_alias = a;
 452                 return -3; /* alias available */
 453             }
 454         }
 455     }
 456 #endif
 457     /* not found, see whether it is an abbreviation */
 458     /* aliases may not be abbreviated */
 459     n = strlen( keyword );
 460     for(i=0; opts[i].short_opt; i++ ) {
 461         if( opts[i].long_opt && !strncmp( opts[i].long_opt, keyword, n ) ) {
 462             int j;
 463             for(j=i+1; opts[j].short_opt; j++ ) {
 464                 if( opts[j].long_opt
 465                     && !strncmp( opts[j].long_opt, keyword, n ) )
 466                     return -2;  /* abbreviation is ambiguous */
 467             }
 468             return i;
 469         }
 470     }
 471     return -1;
 472 }
 473
 474 int
 475 arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts)
 476 {
 477     int idx;
 478     int argc;
 479     char **argv;
 480     char *s, *s2;
 481     int i;
 482
 483     initialize( arg, NULL, NULL );
 484     argc = *arg->argc;
 485     argv = *arg->argv;
 486     idx = arg->internal.idx;
 487
 488     if( !idx && argc && !(arg->flags & (1<<4)) ) { /* skip the first entry */
 489         argc--; argv++; idx++;
 490     }
 491
 492   next_one:
 493     if( !argc ) { /* no more args */
 494         arg->r_opt = 0;
 495         goto leave; /* ready */
 496     }
 497
 498     s = *argv;
 499     arg->internal.last = s;
 500
 501     if( arg->internal.stopped && (arg->flags & (1<<1)) ) {
 502         arg->r_opt = -1;  /* not an option but a argument */
 503         arg->r_type = 2;
 504         arg->r.ret_str = s;
 505         argc--; argv++; idx++; /* set to next one */
 506     }
 507     else if( arg->internal.stopped ) { /* ready */
 508         arg->r_opt = 0;
 509         goto leave;
 510     }
 511     else if( *s == '-' && s[1] == '-' ) { /* long option */
 512         char *argpos;
 513
 514         arg->internal.inarg = 0;
 515         if( !s[2] && !(arg->flags & (1<<3)) ) { /* stop option processing */
 516             arg->internal.stopped = 1;
 517             argc--; argv++; idx++;
 518             goto next_one;
 519         }
 520
 521         argpos = strchr( s+2, '=' );
 522         if( argpos )
 523             *argpos = 0;
 524         i = find_long_option( arg, opts, s+2 );
 525         if( argpos )
 526             *argpos = '=';
 527
 528         if( i < 0 && !strcmp( "help", s+2) ) {
 529             if( !(arg->flags & (1<<6)) ) {
 530                 show_help(opts, arg->flags);
 531             }
 532         }
 533         else if( i < 0 && !strcmp( "version", s+2) ) {
 534             if( !(arg->flags & (1<<6)) ) {
 535                 show_version();
 536                 exit(0);
 537             }
 538         }
 539         else if( i < 0 && !strcmp( "warranty", s+2) ) {
 540             puts( strusage(16) );
 541             exit(0);
 542         }
 543         else if( i < 0 && !strcmp( "dump-options", s+2) ) {
 544             for(i=0; opts[i].short_opt; i++ ) {
 545                 if( opts[i].long_opt )
 546                     printf( "--%s\n", opts[i].long_opt );
 547             }
 548             fputs("--dump-options\n--help\n--version\n--warranty\n", stdout );
 549             exit(0);
 550         }
 551
 552         if( i == -2 ) /* ambiguous option */
 553             arg->r_opt = -8;
 554         else if( i == -1 ) {
 555             arg->r_opt = -2;
 556             arg->r.ret_str = s+2;
 557         }
 558         else
 559             arg->r_opt = opts[i].short_opt;
 560         if( i < 0 )
 561             ;
 562         else if( (opts[i].flags & 7) ) {
 563             if( argpos ) {
 564                 s2 = argpos+1;
 565                 if( !*s2 )
 566                     s2 = NULL;
 567             }
 568             else
 569                 s2 = argv[1];
 570             if( !s2 && (opts[i].flags & 8) ) { /* no argument but it is okay*/
 571                 arg->r_type = 0;               /* because it is optional */
 572             }
 573             else if( !s2 ) {
 574                 arg->r_opt = -3; /* missing argument */
 575             }
 576             else if( !argpos && *s2 == '-' && (opts[i].flags & 8) ) {
 577                 /* the argument is optional and the next seems to be
 578                  * an option. We do not check this possible option
 579                  * but assume no argument */
 580                 arg->r_type = 0;
 581             }
 582             else {
 583                 set_opt_arg(arg, opts[i].flags, s2);
 584                 if( !argpos ) {
 585                     argc--; argv++; idx++; /* skip one */
 586                 }
 587             }
 588         }
 589         else { /* does not take an argument */
 590             if( argpos )
 591                 arg->r_type = -6; /* argument not expected */
 592             else
 593                 arg->r_type = 0;
 594         }
 595         argc--; argv++; idx++; /* set to next one */
 596     }
 597     else if( (*s == '-' && s[1]) || arg->internal.inarg ) { /* short option */
 598         int dash_kludge = 0;
 599         i = 0;
 600         if( !arg->internal.inarg ) {
 601             arg->internal.inarg++;
 602             if( arg->flags & (1<<5) ) {
 603                 for(i=0; opts[i].short_opt; i++ )
 604                     if( opts[i].long_opt && !strcmp( opts[i].long_opt, s+1)) {
 605                         dash_kludge=1;
 606                         break;
 607                     }
 608             }
 609         }
 610         s += arg->internal.inarg;
 611
 612         if( !dash_kludge ) {
 613             for(i=0; opts[i].short_opt; i++ )
 614                 if( opts[i].short_opt == *s )
 615                     break;
 616         }
 617
 618         if( !opts[i].short_opt && ( *s == 'h' || *s == '?' ) ) {
 619             if( !(arg->flags & (1<<6)) ) {
 620                 show_help(opts, arg->flags);
 621             }
 622         }
 623
 624         arg->r_opt = opts[i].short_opt;
 625         if( !opts[i].short_opt ) {
 626             arg->r_opt = (opts[i].flags & 256)? -7:-2;
 627             arg->internal.inarg++; /* point to the next arg */
 628             arg->r.ret_str = s;
 629         }
 630         else if( (opts[i].flags & 7) ) {
 631             if( s[1] && !dash_kludge ) {
 632                 s2 = s+1;
 633                 set_opt_arg(arg, opts[i].flags, s2);
 634             }
 635             else {
 636                 s2 = argv[1];
 637                 if( !s2 && (opts[i].flags & 8) ) { /* no argument but it is okay*/
 638                     arg->r_type = 0;               /* because it is optional */
 639                 }
 640                 else if( !s2 ) {
 641                     arg->r_opt = -3; /* missing argument */
 642                 }
 643                 else if( *s2 == '-' && s2[1] && (opts[i].flags & 8) ) {
 644                     /* the argument is optional and the next seems to be
 645                      * an option. We do not check this possible option
 646                      * but assume no argument */
 647                     arg->r_type = 0;
 648                 }
 649                 else {
 650                     set_opt_arg(arg, opts[i].flags, s2);
 651                     argc--; argv++; idx++; /* skip one */
 652                 }
 653             }
 654             s = "x"; /* so that !s[1] yields false */
 655         }
 656         else { /* does not take an argument */
 657             arg->r_type = 0;
 658             arg->internal.inarg++; /* point to the next arg */
 659         }
 660         if( !s[1] || dash_kludge ) { /* no more concatenated short options */
 661             arg->internal.inarg = 0;
 662             argc--; argv++; idx++;
 663         }
 664     }
 665     else if( arg->flags & (1<<2) ) {
 666         arg->r_opt = -1;  /* not an option but a argument */
 667         arg->r_type = 2;
 668         arg->r.ret_str = s;
 669         argc--; argv++; idx++; /* set to next one */
 670     }
 671     else {
 672         arg->internal.stopped = 1; /* stop option processing */
 673         goto next_one;
 674     }
 675
 676   leave:
 677     *arg->argc = argc;
 678     *arg->argv = argv;
 679     arg->internal.idx = idx;
 680     return arg->r_opt;
 681 }
 682
 683
 684
 685 static int
 686 set_opt_arg(ARGPARSE_ARGS *arg, unsigned flags, char *s)
 687 {
 688     int base = (flags & 16)? 0 : 10;
 689
 690     switch( arg->r_type = (flags & 7) ) {
 691       case 1: /* takes int argument */
 692         arg->r.ret_int = (int)strtol(s,NULL,base);
 693         return 0;
 694       case 3: /* takes long argument   */
 695         arg->r.ret_long= strtol(s,NULL,base);
 696         return 0;
 697       case 4: /* takes ulong argument  */
 698         arg->r.ret_ulong= strtoul(s,NULL,base);
 699         return 0;
 700       case 2: /* takes string argument */
 701       default:
 702         arg->r.ret_str = s;
 703         return 1;
 704     }
 705 }
 706
 707
 708 static size_t
 709 long_opt_strlen( ARGPARSE_OPTS *o )
 710 {
 711     size_t n = strlen(o->long_opt);
 712
 713     if( o->description && *o->description == '|' ) {
 714         const char *s;
 715
 716         s=o->description+1;
 717         if( *s != '=' )
 718             n++;
 719         for(; *s && *s != '|'; s++ )
 720             n++;
 721     }
 722     return n;
 723 }
 724
 725 /****************
 726  * Print formatted help. The description string has some special
 727  * meanings:
 728  *  - A description string which is "@" suppresses help output for
 729  *    this option
 730  *  - a description,ine which starts with a '@' and is followed by
 731  *    any other characters is printed as is; this may be used for examples
 732  *    ans such.
 733  *  - A description which starts with a '|' outputs the string between this
 734  *    bar and the next one as arguments of the long option.
 735  */
 736 static void
 737 show_help( ARGPARSE_OPTS *opts, unsigned flags )
 738 {
 739     const char *s;
 740
 741     show_version();
 742     putchar('\n');
 743     s = strusage(41);
 744     puts(s);
 745     if( opts[0].description ) { /* auto format the option description */
 746         int i,j, indent;
 747         /* get max. length of long options */
 748         for(i=indent=0; opts[i].short_opt; i++ ) {
 749             if( opts[i].long_opt )
 750                 if( !opts[i].description || *opts[i].description != '@' )
 751                     if( (j=long_opt_strlen(opts+i)) > indent && j < 35 )
 752                          indent = j;
 753         }
 754         /* example: " -v, --verbose   Viele Sachen ausgeben" */
 755         indent += 10;
 756         if( *opts[0].description != '@' )
 757             puts("Options:");
 758         for(i=0; opts[i].short_opt; i++ ) {
 759             s = _( opts[i].description );
 760             if( s && *s== '@' && !s[1] ) /* hide this line */
 761                 continue;
 762             if( s && *s == '@' ) { /* unindented comment only line */
 763                 for(s++; *s; s++ ) {
 764                     if( *s == '\n' ) {
 765                         if( s[1] )
 766                             putchar('\n');
 767                     }
 768                     else
 769                         putchar(*s);
 770                 }
 771                 putchar('\n');
 772                 continue;
 773             }
 774
 775             j = 3;
 776             if( opts[i].short_opt < 256 ) {
 777                 printf(" -%c", opts[i].short_opt );
 778                 if( !opts[i].long_opt ) {
 779                     if(s && *s == '|' ) {
 780                         putchar(' '); j++;
 781                         for(s++ ; *s && *s != '|'; s++, j++ )
 782                             putchar(*s);
 783                         if( *s )
 784                             s++;
 785                     }
 786                 }
 787             }
 788             else
 789                 fputs("   ", stdout);
 790             if( opts[i].long_opt ) {
 791                 j += printf("%c --%s", opts[i].short_opt < 256?',':' ',
 792                                        opts[i].long_opt );
 793                 if(s && *s == '|' ) {
 794                     if( *++s != '=' ) {
 795                         putchar(' ');
 796                         j++;
 797                     }
 798                     for( ; *s && *s != '|'; s++, j++ )
 799                         putchar(*s);
 800                     if( *s )
 801                         s++;
 802                 }
 803                 fputs("   ", stdout);
 804                 j += 3;
 805             }
 806             for(;j < indent; j++ )
 807                 putchar(' ');
 808             if( s ) {
 809                 if( *s && j > indent ) {
 810                     putchar('\n');
 811                     for(j=0;j < indent; j++ )
 812                         putchar(' ');
 813                 }
 814                 for(; *s; s++ ) {
 815                     if( *s == '\n' ) {
 816                         if( s[1] ) {
 817                             putchar('\n');
 818                             for(j=0;j < indent; j++ )
 819                                 putchar(' ');
 820                         }
 821                     }
 822                     else
 823                         putchar(*s);
 824                 }
 825             }
 826             putchar('\n');
 827         }
 828         if( flags & 32 )
 829             puts("\n(A single dash may be used instead of the double ones)");
 830     }
 831     if( (s=strusage(19)) ) {  /* bug reports to ... */
 832         putchar('\n');
 833         fputs(s, stdout);
 834     }
 835     fflush(stdout);
 836     exit(0);
 837 }
 838
 839 static void
 840 show_version()
 841 {
 842     const char *s;
 843     int i;
 844     /* version line */
 845     fputs(strusage(11), stdout);
 846     if( (s=strusage(12)) )
 847         printf(" (%s)", s );
 848     printf(" %s\n", strusage(13) );
 849     /* additional version lines */
 850     for(i=20; i < 30; i++ )
 851         if( (s=strusage(i)) )
 852             printf("%s\n", s );
 853     /* copyright string */
 854     if( (s=strusage(14)) )
 855         printf("%s\n", s );
 856     /* Licence string.  */
 857     if( (s=strusage (10)) )
 858         printf("%s\n", s );
 859     /* copying conditions */
 860     if( (s=strusage(15)) )
 861         fputs(s, stdout);
 862     /* thanks */
 863     if( (s=strusage(18)) )
 864         fputs(s, stdout);
 865     /* additional program info */
 866     for(i=30; i < 40; i++ )
 867         if( (s=strusage(i)) )
 868             fputs( (const byte*)s, stdout);
 869     fflush(stdout);
 870 }
 871
 872
 873 void
 874 usage( int level )
 875 {
 876     if( !level ) {
 877         fprintf(stderr,"%s %s; %s\n", strusage(11), strusage(13),
 878                                                      strusage(14) );
 879         fflush(stderr);
 880     }
 881     else if( level == 1 ) {
 882         fputs(strusage(40),stderr);
 883         exit(2);
 884     }
 885     else if( level == 2 ) {
 886         puts(strusage(41));
 887         exit(0);
 888     }
 889 }
 890
 891 /* Level
 892  *     0: Copyright String auf stderr ausgeben
 893  *     1: Kurzusage auf stderr ausgeben und beenden
 894  *     2: Langusage auf stdout ausgeben und beenden
 895  *    10: Return license info string
 896  *    11: name of program
 897  *    12: optional name of package which includes this program.
 898  *    13: version  string
 899  *    14: copyright string
 900  *    15: Short copying conditions (with LFs)
 901  *    16: Long copying conditions (with LFs)
 902  *    17: Optional printable OS name
 903  *    18: Optional thanks list   (with LFs)
 904  *    19: Bug report info
 905  *20..29: Additional lib version strings.
 906  *30..39: Additional program info (with LFs)
 907  *    40: short usage note (with LF)
 908  *    41: long usage note (with LF)
 909  */
 910 const char *
 911 default_strusage( int level )
 912 {
 913     const char *p = NULL;
 914     switch( level ) {
 915       case 10: p = ("License GPLv3+: GNU GPL version 3 or later "
 916                     "<http://gnu.org/licenses/gpl.html>");
 917         break;
 918       case 11: p = "foo"; break;
 919       case 13: p = "0.0"; break;
 920       case 14: p = "Copyright (C) 2007 Free Software Foundation, Inc."; break;
 921       case 15: p =
 922 "This is free software: you are free to change and redistribute it.\n"
 923 "There is NO WARRANTY, to the extent permitted by law.\n";
 924         break;
 925       case 16:  p =
 926 "This is free software; you can redistribute it and/or modify\n"
 927 "it under the terms of the GNU General Public License as published by\n"
 928 "the Free Software Foundation; either version 3 of the License, or\n"
 929 "(at your option) any later version.\n\n"
 930 "It is distributed in the hope that it will be useful,\n"
 931 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 932 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 933 "GNU General Public License for more details.\n\n"
 934 "You should have received a copy of the GNU General Public License\n"
 935 "along with this software.  If not, see <http://www.gnu.org/licenses/>.\n";
 936         break;
 937       case 40: /* short and long usage */
 938       case 41: p = ""; break;
 939     }
 940
 941     return p;
 942 }
 943
 944
 945
 946 #ifdef TEST
 947 static struct {
 948     int verbose;
 949     int debug;
 950     char *outfile;
 951     char *crf;
 952     int myopt;
 953     int echo;
 954     int a_long_one;
 955 }opt;
 956
 957 int
 958 main(int argc, char **argv)
 959 {
 960     ARGPARSE_OPTS opts[] = {
 961     { 'v', "verbose",   0 , "Laut sein"},
 962     { 'e', "echo"   ,   0 , "Zeile ausgeben, damit wir sehen, was wir einegegeben haben"},
 963     { 'd', "debug",     0 , "Debug\nfalls mal etasws\nSchief geht"},
 964     { 'o', "output",    2   },
 965     { 'c', "cross-ref", 2|8, "cross-reference erzeugen\n" },
 966     { 'm', "my-option", 1|8 },
 967     { 500, "a-long-option", 0 },
 968     {0} };
 969     ARGPARSE_ARGS pargs = { &argc, &argv, 2|4|32 };
 970     int i;
 971
 972     while( ArgParse( &pargs, opts) ) {
 973         switch( pargs.r_opt ) {
 974           case -1 : printf( "arg=`%s'\n", pargs.r.ret_str); break;
 975           case 'v': opt.verbose++; break;
 976           case 'e': opt.echo++; break;
 977           case 'd': opt.debug++; break;
 978           case 'o': opt.outfile = pargs.r.ret_str; break;
 979           case 'c': opt.crf = pargs.r_type? pargs.r.ret_str:"a.crf"; break;
 980           case 'm': opt.myopt = pargs.r_type? pargs.r.ret_int : 1; break;
 981           case 500: opt.a_long_one++;  break;
 982           default : pargs.err = 1; break; /* force warning output */
 983         }
 984     }
 985     for(i=0; i < argc; i++ )
 986         printf("%3d -> (%s)\n", i, argv[i] );
 987     puts("Options:");
 988     if( opt.verbose )
 989         printf("  verbose=%d\n", opt.verbose );
 990     if( opt.debug )
 991         printf("  debug=%d\n", opt.debug );
 992     if( opt.outfile )
 993         printf("  outfile=`%s'\n", opt.outfile );
 994     if( opt.crf )
 995         printf("  crffile=`%s'\n", opt.crf );
 996     if( opt.myopt )
 997         printf("  myopt=%d\n", opt.myopt );
 998     if( opt.a_long_one )
 999         printf("  a-long-one=%d\n", opt.a_long_one );
1000     if( opt.echo       )
1001         printf("  echo=%d\n", opt.echo );
1002     return 0;
1003 }
1004 #endif
1005
1006 /**** bottom of file ****/