Re: GETARG in Ada?

[Stephen Leake <Stephen.Leake@gsfc.nasa.gov>]

bill@cool writes:

> it should be possible to call the Unix getopt() function from Ada. why
> not do this? getopt is designed to break command line arguments
> easily. 
> 
> <snip man entry>
>
> It uses the GNU getopt(3) routines to do this.

As this last line says, what you want to call from Ada is the GNU
getopt C function. I just ran across this function in some code I was
reading recently, and it does look powerful. Here's the spec from the
gcc sources (edited to remove #ifdefs that handle non-standard
compilers):

/* For communication from `getopt' to the caller.
   When `getopt' finds an option that takes an argument,
   the argument value is returned here.
   Also, when `ordering' is RETURN_IN_ORDER,
   each non-option ARGV-element is returned here.  */

extern char *optarg;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
   and for communication between successive calls to `getopt'.

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

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

extern int optind;

/* Callers store zero here to inhibit the error message `getopt' prints
   for unrecognized options.  */

extern int opterr;

/* Set to an option character which was unrecognized.  */

extern int optopt;

/* Describe the long-named options requested by the application.
   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
   of `struct option' terminated by an element containing a name which is
   zero.

   The field `has_arg' is:
   no_argument		(or 0) if the option does not take an argument,
   required_argument	(or 1) if the option requires an argument,
   optional_argument 	(or 2) if the option takes an optional argument.

   If the field `flag' is not NULL, it points to a variable that is set
   to the value given in the field `val' when the option is found, but
   left unchanged if the option is not found.

   To have a long-named option do something other than set an `int' to
   a compiled-in constant, such as set a value from `optarg', set the
   option's `flag' field to zero and its `val' field to a nonzero
   value (the equivalent single-letter option character, if there is
   one).  For long options that have a zero `flag' field, `getopt'
   returns the contents of the `val' field.  */

struct option
{
  const char *name;
  int has_arg;
  int *flag;
  int val;
};

/* Names for the values of the `has_arg' field of `struct option'.  */

#define	no_argument		0
#define required_argument	1
#define optional_argument	2

extern int getopt (int argc, char *const *argv, const char *shortopts);


It should be possible to write an Ada binding to this, but it's
certainly not a beginner's task. Most of the char *'s will point to
static strings, so you probably don't have to worry about dynamic
string allocation. It would be nice to hide the global variables, but
since the command line is a global resource, maybe they aren't so bad.

Anyone want to give it a shot?

-- Stephe