DOC HOME SITE MAP MAN PAGES GNU INFO SEARCH PRINT BOOK
 

Tk_ParseArgv(3tk)




______________________________________________________________________________


NAME

       Tk_ParseArgv - process command-line options


SYNOPSIS

       #include <tk.h>

       int
       Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)


ARGUMENTS

       Tcl_Interp    *interp     (in)      Interpreter  to  use  for returning
                                           error messages.

       Tk_Window     tkwin       (in)      Window to use when arguments  spec-
                                           ify  Tk  options.  If NULL, then no
                                           Tk options will be processed.

       int           argcPtr     (in/out)  Pointer to number of  arguments  in
                                           argv;  gets modified to hold number
                                           of   unprocessed   arguments   that
                                           remain after the call.

       CONST char    **argv      (in/out)  Command  line  arguments  passed to
                                           main  program.   Modified  to  hold
                                           unprocessed  arguments  that remain
                                           after the call.

       Tk_ArgvInfo   *argTable   (in)      Array of argument descriptors, ter-
                                           minated   by   element   with  type
                                           TK_ARGV_END.

       int           flags       (in)      If non-zero, then it specifies  one
                                           or  more  flags  that  control  the
                                           parsing  of  arguments.   Different
                                           flags  may  be OR'ed together.  The
                                           flags   currently    defined    are
                                           TK_ARGV_DONT_SKIP_FIRST_ARG,
                                           TK_ARGV_NO_ABBREV, TK_ARGV_NO_LEFT-
                                           OVERS, and TK_ARGV_NO_DEFAULTS.
_________________________________________________________________


DESCRIPTION

       Tk_ParseArgv  processes an array of command-line arguments according to
       a table describing the kinds of arguments that are expected.   Each  of
       the  arguments  in argv is processed in turn:  if it matches one of the
       entries in argTable, the argument is processed according to that  entry
       and  discarded.   The  arguments that do not match anything in argTable
       are copied down to the beginning  of  argv  (retaining  their  original
       order) and returned to the caller.  At the end of the call Tk_ParseArgv
       sets *argcPtr to hold the number of arguments that are  left  in  argv,
       and  argv[*argcPtr]  will  hold the value NULL.  Normally, Tk_ParseArgv
       assumes that argv[0] is a command name, so it is treated like an  argu-
       ment  that doesn't match argTable and returned to the caller;  however,
       if the TK_ARGV_DONT_SKIP_FIRST_ARG bit is set  in  flags  then  argv[0]
       will be processed just like the other elements of argv.

       Tk_ParseArgv  normally  returns  the  value TCL_OK.  If an error occurs
       while  parsing  the  arguments,  then   TCL_ERROR   is   returned   and
       Tk_ParseArgv will leave an error message in interp->result in the stan-
       dard Tcl fashion.  In the event of an error return, *argvPtr  will  not
       have  been  modified, but argv could have been partially modified.  The
       possible causes of errors are explained below.

       The argTable array specifies the kinds of arguments that are  expected;
       each of its entries has the following structure:
              typedef struct {
                char *key;
                int type;
                char *src;
                char *dst;
                char *help;
              } Tk_ArgvInfo;
       The  key field is a string such as ``-display'' or ``-bg'' that is com-
       pared with the values in argv.  Type indicates how to process an  argu-
       ment that matches key (more on this below).  Src and dst are additional
       values used in processing the argument.  Their exact usage  depends  on
       type,  but  typically  src indicates a value and dst indicates where to
       store the value.  The char * declarations for src and  dst  are  place-
       holders:   the actual types may be different.  Lastly, help is a string
       giving a brief description of this option;  this string is printed when
       users ask for help about command-line options.

       When processing an argument in argv, Tk_ParseArgv compares the argument
       to each of the key's in argTable.  Tk_ParseArgv selects the first spec-
       ifier  whose  key  matches  the  argument  exactly, if such a specifier
       exists.  Otherwise Tk_ParseArgv selects a specifier for which the argu-
       ment  is  a unique abbreviation.  If the argument is a unique abbrevia-
       tion for more than one specifier, then an error is returned.  If  there
       is  no  matching  entry  in  argTable, then the argument is skipped and
       returned to the caller.

       Once a matching argument specifier is found, Tk_ParseArgv processes the
       argument  according  to  the type field of the specifier.  The argument
       that matched key is called ``the matching argument''  in  the  descrip-
       tions  below.  As part of the processing, Tk_ParseArgv may also use the
       next argument in argv after the  matching  argument,  which  is  called
       ``the  following  argument''.   The legal values for type, and the pro-
       cessing that they cause, are as follows:

       TK_ARGV_END
              Marks the end of the table.  The last  entry  in  argTable  must
              have this type;  all of its other fields are ignored and it will
              never match any arguments.

       TK_ARGV_CONSTANT
              Src is treated as an integer and dst is treated as a pointer  to
              an  integer.   Src  is stored at *dst.  The matching argument is
              discarded.

       TK_ARGV_INT
              The following argument must contain an  integer  string  in  the
              format accepted by strtol (e.g. ``0'' and ``0x'' prefixes may be
              used to specify octal  or  hexadecimal  numbers,  respectively).
              Dst  is treated as a pointer to an integer;  the following argu-
              ment is converted to an integer value and stored at  *dst.   Src
              is  ignored.  The matching and following arguments are discarded
              from argv.

       TK_ARGV_FLOAT
              The following argument must contain a floating-point  number  in
              the format accepted by strtol.  Dst is treated as the address of
              an double-precision floating point value;  the  following  argu-
              ment  is  converted  to  a  double-precision value and stored at
              *dst.  The matching and following arguments are  discarded  from
              argv.

       TK_ARGV_STRING
              In  this  form,  dst  is  treated  as  a  pointer to a (char *);
              Tk_ParseArgv stores at *dst a pointer to the following argument,
              and  discards  the  matching  and following arguments from argv.
              Src is ignored.

       TK_ARGV_UID
              This form is similar to TK_ARGV_STRING, except that the argument
              is turned into a Tk_Uid by calling Tk_GetUid.  Dst is treated as
              a pointer to a Tk_Uid; Tk_ParseArgv stores at  *dst  the  Tk_Uid
              corresponding to the following argument, and discards the match-
              ing and following arguments from argv.  Src is ignored.

       TK_ARGV_CONST_OPTION
              This form causes a Tk option to be set (as if the option command
              had  been  invoked).  The src field is treated as a pointer to a
              string giving the value of an option, and dst is  treated  as  a
              pointer  to  the  name  of the option.  The matching argument is
              discarded.  If tkwin is NULL, then argument specifiers  of  this
              type are ignored (as if they did not exist).

       TK_ARGV_OPTION_VALUE
              This  form  is  similar to TK_ARGV_CONST_OPTION, except that the
              value of the option is taken from the following argument instead
              of  from  src.   Dst  is used as the name of the option.  Src is
              ignored.  The matching and following  arguments  are  discarded.
              If  tkwin  is  NULL,  then  argument specifiers of this type are
              ignored (as if they did not exist).

       TK_ARGV_OPTION_NAME_VALUE
              In this case the following argument is taken as the name of a Tk
              option  and  the  argument  after that is taken as the value for
              that option.  Both src and dst are ignored.  All three arguments
              are discarded from argv.  If tkwin is NULL, then argument speci-
              fiers of this type are ignored (as if they did not exist).

       TK_ARGV_HELP
              When this kind of option is encountered, Tk_ParseArgv  uses  the
              help  fields  of argTable to format a message describing all the
              valid arguments.  The message is placed  in  interp->result  and
              Tk_ParseArgv  returns  TCL_ERROR.  When this happens, the caller
              normally prints the help message and aborts.  If the  key  field
              of  a  TK_ARGV_HELP  specifier  is NULL, then the specifier will
              never match any arguments;  in this case  the  specifier  simply
              provides  extra  documentation, which will be included when some
              other TK_ARGV_HELP entry causes help information to be returned.

       TK_ARGV_REST
              This  option is used by programs or commands that allow the last
              several of their options to be the name and/or options for  some
              other  program.   If  a  TK_ARGV_REST  argument  is  found, then
              Tk_ParseArgv doesn't process any of the remaining arguments;  it
              returns  them all at the beginning of argv (along with any other
              unprocessed arguments).  In addition, Tk_ParseArgv treats dst as
              the address of an integer value, and stores at *dst the index of
              the first of the TK_ARGV_REST  options  in  the  returned  argv.
              This  allows the program to distinguish the TK_ARGV_REST options
              from other unprocessed options that preceded the TK_ARGV_REST.

       TK_ARGV_FUNC
              For this kind of argument, src is treated as the  address  of  a
              procedure,  which  is invoked to process the following argument.
              The procedure should have the following structure:
                     int
                     func(dst, key, nextArg)
                       char *dst;
                       char *key;
                       char *nextArg;
                     {
                     }
              The dst and key parameters will contain the corresponding fields
              from the argTable entry, and nextArg will point to the following
              argument from argv (or NULL if there aren't any  more  arguments
              left  in  argv).   If  func  uses  nextArg (so that Tk_ParseArgv
              should discard it), then  it  should  return  1.   Otherwise  it
              should return 0 and TkParseArgv will process the following argu-
              ment in the normal fashion.  In either event the matching  argu-
              ment is discarded.

       TK_ARGV_GENFUNC
              This  form provides a more general procedural escape.  It treats
              src as the address of a procedure, and passes that procedure all
              of  the remaining arguments.  The procedure should have the fol-
              lowing form:
                     int
                     genfunc(dst, interp, key, argc, argv)
                       char *dst;
                       Tcl_Interp *interp;
                       char *key;
                       int argc;
                       char **argv;
                     {
                     }
              The dst and key parameters will contain the corresponding fields
              from  the argTable entry.  Interp will be the same as the interp
              argument to Tcl_ParseArgv.  Argc and argv refer to  all  of  the
              options  after  the  matching  one.   Genfunc should behave in a
              fashion similar to Tk_ParseArgv:  parse as many of the remaining
              arguments as it can, then return any that are left by compacting
              them to the beginning of argv (starting  at  argv[0]).   Genfunc
              should  return  a  count of how many arguments are left in argv;
              Tk_ParseArgv will process them.  If genfunc encounters an  error
              then  it should leave an error message in interp->result, in the
              usual  Tcl  fashion,  and  return   -1;    when   this   happens
              Tk_ParseArgv will abort its processing and return TCL_ERROR.


FLAGS

       TK_ARGV_DONT_SKIP_FIRST_ARG
              Tk_ParseArgv  normally  treats  argv[0]  as a program or command
              name, and returns it to the caller just as if it hadn't  matched
              argTable.  If this flag is given, then argv[0] is not given spe-
              cial treatment.

       TK_ARGV_NO_ABBREV
              Normally, Tk_ParseArgv accepts unique abbreviations for key val-
              ues  in argTable.  If this flag is given then only exact matches
              will be acceptable.

       TK_ARGV_NO_LEFTOVERS
              Normally, Tk_ParseArgv returns  unrecognized  arguments  to  the
              caller.   If  this  bit  is  set in flags then Tk_ParseArgv will
              return an error if it encounters any argument that doesn't match
              argTable.   The  only  exception  to this rule is argv[0], which
              will be returned to  the  caller  with  no  errors  as  long  as
              TK_ARGV_DONT_SKIP_FIRST_ARG isn't specified.

       TK_ARGV_NO_DEFAULTS
              Normally,  Tk_ParseArgv  searches  an internal table of standard
              argument specifiers in addition to argTable.  If this bit is set
              in  flags,  then Tk_ParseArgv will use only argTable and not its
              default table.


EXAMPLE

       Here is an example definition of an argTable and  some  sample  command
       lines  that  use the options.  Note the effect on argc and argv;  argu-
       ments processed by Tk_ParseArgv are eliminated from argv, and  argc  is
       updated to reflect reduced number of arguments.
              /*
               * Define and set default values for globals.
               */
              int debugFlag = 0;
              int numReps = 100;
              char defaultFileName[] = "out";
              char *fileName = defaultFileName;
              Boolean exec = FALSE;

              /*
               * Define option descriptions.
               */
              Tk_ArgvInfo argTable[] = {
                {"-X", TK_ARGV_CONSTANT, (char *) 1, (char *) &debugFlag,
                   "Turn on debugging printfs"},
                {"-N", TK_ARGV_INT, (char *) NULL, (char *) &numReps,
                   "Number of repetitions"},
                {"-of", TK_ARGV_STRING, (char *) NULL, (char *) &fileName,
                   "Name of file for output"},
                {"x", TK_ARGV_REST, (char *) NULL, (char *) &exec,
                   "File to exec, followed by any arguments (must be last argument)."},
                {(char *) NULL, TK_ARGV_END, (char *) NULL, (char *) NULL,
                    (char *) NULL}
              };

              main(argc, argv)
                int argc;
                char *argv[];
              {
                ...

                if (Tk_ParseArgv(interp, tkwin, &argc, argv, argTable, 0) != TCL_OK) {
                   fprintf(stderr, "%s\n", interp->result);
                   exit(1);
                }

                /*
                 * Remainder of the program.
                 */
              }

       Note  that  default  values  can  be  assigned  to  variables  named in
       argTable:  the variables will only be  overwritten  if  the  particular
       arguments are present in argv.  Here are some example command lines and
       their effects.
              prog -N 200 infile# just sets the numReps variable to 200
              prog -of out200 infile # sets fileName to reference "out200"
              prog -XN 10 infile# sets the debug flag, also sets numReps
       In all of the above examples, argc will be set by  Tk_ParseArgv  to  2,
       argv[0]  will be ``prog'', argv[1] will be ``infile'', and argv[2] will
       be NULL.


KEYWORDS

       arguments, command line, options

Tk                                                             Tk_ParseArgv(3)

Man(1) output converted with man2html