| '\" |
| '\" Copyright (c) 1990-1992 The Regents of the University of California. |
| '\" Copyright (c) 1994-1996 Sun Microsystems, Inc. |
| '\" |
| '\" See the file "license.terms" for information on usage and redistribution |
| '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
| '\" |
| '\" RCS: @(#) $Id: ParseArgv.3,v 1.3 2002/01/25 21:09:36 dgp Exp $ |
| '\" |
| '\" The definitions below are for supplemental macros used in Tcl/Tk |
| '\" manual entries. |
| '\" |
| '\" .AP type name in/out ?indent? |
| '\" Start paragraph describing an argument to a library procedure. |
| '\" type is type of argument (int, etc.), in/out is either "in", "out", |
| '\" or "in/out" to describe whether procedure reads or modifies arg, |
| '\" and indent is equivalent to second arg of .IP (shouldn't ever be |
| '\" needed; use .AS below instead) |
| '\" |
| '\" .AS ?type? ?name? |
| '\" Give maximum sizes of arguments for setting tab stops. Type and |
| '\" name are examples of largest possible arguments that will be passed |
| '\" to .AP later. If args are omitted, default tab stops are used. |
| '\" |
| '\" .BS |
| '\" Start box enclosure. From here until next .BE, everything will be |
| '\" enclosed in one large box. |
| '\" |
| '\" .BE |
| '\" End of box enclosure. |
| '\" |
| '\" .CS |
| '\" Begin code excerpt. |
| '\" |
| '\" .CE |
| '\" End code excerpt. |
| '\" |
| '\" .VS ?version? ?br? |
| '\" Begin vertical sidebar, for use in marking newly-changed parts |
| '\" of man pages. The first argument is ignored and used for recording |
| '\" the version when the .VS was added, so that the sidebars can be |
| '\" found and removed when they reach a certain age. If another argument |
| '\" is present, then a line break is forced before starting the sidebar. |
| '\" |
| '\" .VE |
| '\" End of vertical sidebar. |
| '\" |
| '\" .DS |
| '\" Begin an indented unfilled display. |
| '\" |
| '\" .DE |
| '\" End of indented unfilled display. |
| '\" |
| '\" .SO |
| '\" Start of list of standard options for a Tk widget. The |
| '\" options follow on successive lines, in four columns separated |
| '\" by tabs. |
| '\" |
| '\" .SE |
| '\" End of list of standard options for a Tk widget. |
| '\" |
| '\" .OP cmdName dbName dbClass |
| '\" Start of description of a specific option. cmdName gives the |
| '\" option's name as specified in the class command, dbName gives |
| '\" the option's name in the option database, and dbClass gives |
| '\" the option's class in the option database. |
| '\" |
| '\" .UL arg1 arg2 |
| '\" Print arg1 underlined, then print arg2 normally. |
| '\" |
| '\" RCS: @(#) $Id: man.macros,v 1.4 2000/08/25 06:18:32 ericm Exp $ |
| '\" |
| '\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages. |
| .if t .wh -1.3i ^B |
| .nr ^l \n(.l |
| .ad b |
| '\" # Start an argument description |
| .de AP |
| .ie !"\\$4"" .TP \\$4 |
| .el \{\ |
| . ie !"\\$2"" .TP \\n()Cu |
| . el .TP 15 |
| .\} |
| .ta \\n()Au \\n()Bu |
| .ie !"\\$3"" \{\ |
| \&\\$1 \\fI\\$2\\fP (\\$3) |
| .\".b |
| .\} |
| .el \{\ |
| .br |
| .ie !"\\$2"" \{\ |
| \&\\$1 \\fI\\$2\\fP |
| .\} |
| .el \{\ |
| \&\\fI\\$1\\fP |
| .\} |
| .\} |
| .. |
| '\" # define tabbing values for .AP |
| .de AS |
| .nr )A 10n |
| .if !"\\$1"" .nr )A \\w'\\$1'u+3n |
| .nr )B \\n()Au+15n |
| .\" |
| .if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n |
| .nr )C \\n()Bu+\\w'(in/out)'u+2n |
| .. |
| .AS Tcl_Interp Tcl_CreateInterp in/out |
| '\" # BS - start boxed text |
| '\" # ^y = starting y location |
| '\" # ^b = 1 |
| .de BS |
| .br |
| .mk ^y |
| .nr ^b 1u |
| .if n .nf |
| .if n .ti 0 |
| .if n \l'\\n(.lu\(ul' |
| .if n .fi |
| .. |
| '\" # BE - end boxed text (draw box now) |
| .de BE |
| .nf |
| .ti 0 |
| .mk ^t |
| .ie n \l'\\n(^lu\(ul' |
| .el \{\ |
| .\" Draw four-sided box normally, but don't draw top of |
| .\" box if the box started on an earlier page. |
| .ie !\\n(^b-1 \{\ |
| \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul' |
| .\} |
| .el \}\ |
| \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul' |
| .\} |
| .\} |
| .fi |
| .br |
| .nr ^b 0 |
| .. |
| '\" # VS - start vertical sidebar |
| '\" # ^Y = starting y location |
| '\" # ^v = 1 (for troff; for nroff this doesn't matter) |
| .de VS |
| .if !"\\$2"" .br |
| .mk ^Y |
| .ie n 'mc \s12\(br\s0 |
| .el .nr ^v 1u |
| .. |
| '\" # VE - end of vertical sidebar |
| .de VE |
| .ie n 'mc |
| .el \{\ |
| .ev 2 |
| .nf |
| .ti 0 |
| .mk ^t |
| \h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n' |
| .sp -1 |
| .fi |
| .ev |
| .\} |
| .nr ^v 0 |
| .. |
| '\" # Special macro to handle page bottom: finish off current |
| '\" # box/sidebar if in box/sidebar mode, then invoked standard |
| '\" # page bottom macro. |
| .de ^B |
| .ev 2 |
| 'ti 0 |
| 'nf |
| .mk ^t |
| .if \\n(^b \{\ |
| .\" Draw three-sided box if this is the box's first page, |
| .\" draw two sides but no top otherwise. |
| .ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c |
| .el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c |
| .\} |
| .if \\n(^v \{\ |
| .nr ^x \\n(^tu+1v-\\n(^Yu |
| \kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c |
| .\} |
| .bp |
| 'fi |
| .ev |
| .if \\n(^b \{\ |
| .mk ^y |
| .nr ^b 2 |
| .\} |
| .if \\n(^v \{\ |
| .mk ^Y |
| .\} |
| .. |
| '\" # DS - begin display |
| .de DS |
| .RS |
| .nf |
| .sp |
| .. |
| '\" # DE - end display |
| .de DE |
| .fi |
| .RE |
| .sp |
| .. |
| '\" # SO - start of list of standard options |
| .de SO |
| .SH "STANDARD OPTIONS" |
| .LP |
| .nf |
| .ta 5.5c 11c |
| .ft B |
| .. |
| '\" # SE - end of list of standard options |
| .de SE |
| .fi |
| .ft R |
| .LP |
| See the \\fBoptions\\fR manual entry for details on the standard options. |
| .. |
| '\" # OP - start of full description for a single option |
| .de OP |
| .LP |
| .nf |
| .ta 4c |
| Command-Line Name: \\fB\\$1\\fR |
| Database Name: \\fB\\$2\\fR |
| Database Class: \\fB\\$3\\fR |
| .fi |
| .IP |
| .. |
| '\" # CS - begin code excerpt |
| .de CS |
| .RS |
| .nf |
| .ta .25i .5i .75i 1i |
| .. |
| '\" # CE - end code excerpt |
| .de CE |
| .fi |
| .RE |
| .. |
| .de UL |
| \\$1\l'|0\(ul'\\$2 |
| .. |
| .TH Tk_ParseArgv 3 "" Tk "Tk Library Procedures" |
| .BS |
| .SH NAME |
| Tk_ParseArgv \- process command-line options |
| .SH SYNOPSIS |
| .nf |
| \fB#include <tk.h>\fR |
| .sp |
| int |
| \fBTk_ParseArgv\fR(\fIinterp, tkwin, argcPtr, argv, argTable, flags\fR) |
| .SH ARGUMENTS |
| .AS Tk_ArgvInfo *argTable |
| .AP Tcl_Interp *interp in |
| Interpreter to use for returning error messages. |
| .AP Tk_Window tkwin in |
| Window to use when arguments specify Tk options. If NULL, then |
| no Tk options will be processed. |
| .AP int argcPtr in/out |
| Pointer to number of arguments in argv; gets modified to hold |
| number of unprocessed arguments that remain after the call. |
| .AP "CONST char" **argv in/out |
| Command line arguments passed to main program. Modified to |
| hold unprocessed arguments that remain after the call. |
| .AP Tk_ArgvInfo *argTable in |
| Array of argument descriptors, terminated by element with |
| type TK_ARGV_END. |
| .AP 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_LEFTOVERS, and TK_ARGV_NO_DEFAULTS. |
| .BE |
| .SH DESCRIPTION |
| .PP |
| \fBTk_ParseArgv\fR processes an array of command-line arguments according |
| to a table describing the kinds of arguments that are expected. |
| Each of the arguments in \fIargv\fR is processed in turn: if it matches |
| one of the entries in \fIargTable\fR, the argument is processed |
| according to that entry and discarded. The arguments that do not |
| match anything in \fIargTable\fR are copied down to the beginning |
| of \fIargv\fR (retaining their original order) and returned to |
| the caller. At the end of the call |
| \fBTk_ParseArgv\fR sets \fI*argcPtr\fR to hold the number of |
| arguments that are left in \fIargv\fR, and \fIargv[*argcPtr]\fR |
| will hold the value NULL. Normally, \fBTk_ParseArgv\fR |
| assumes that \fIargv[0]\fR is a command name, so it is treated like |
| an argument that doesn't match \fIargTable\fR and returned to the |
| caller; however, if the TK_ARGV_DONT_SKIP_FIRST_ARG bit is set in |
| \fIflags\fR then \fIargv[0]\fR will be processed just like the other |
| elements of \fIargv\fR. |
| .PP |
| \fBTk_ParseArgv\fR normally returns the value TCL_OK. If an error |
| occurs while parsing the arguments, then TCL_ERROR is returned and |
| \fBTk_ParseArgv\fR will leave an error message in \fIinterp->result\fR |
| in the standard Tcl fashion. In |
| the event of an error return, \fI*argvPtr\fR will not have been |
| modified, but \fIargv\fR could have been partially modified. The |
| possible causes of errors are explained below. |
| .PP |
| The \fIargTable\fR array specifies the kinds of arguments that are |
| expected; each of its entries has the following structure: |
| .CS |
| typedef struct { |
| char *\fIkey\fR; |
| int \fItype\fR; |
| char *\fIsrc\fR; |
| char *\fIdst\fR; |
| char *\fIhelp\fR; |
| } Tk_ArgvInfo; |
| .CE |
| The \fIkey\fR field is a string such as ``\-display'' or ``\-bg'' |
| that is compared with the values in \fIargv\fR. \fIType\fR |
| indicates how to process an argument that matches \fIkey\fR |
| (more on this below). \fISrc\fR and \fIdst\fR are additional |
| values used in processing the argument. Their exact usage |
| depends on \fItype\fR, but typically \fIsrc\fR indicates |
| a value and \fIdst\fR indicates where to store the |
| value. The \fBchar *\fR declarations for \fIsrc\fR and \fIdst\fR |
| are placeholders: the actual types may be different. Lastly, |
| \fIhelp\fR is a string giving a brief description |
| of this option; this string is printed when users ask for help |
| about command-line options. |
| .PP |
| When processing an argument in \fIargv\fR, \fBTk_ParseArgv\fR |
| compares the argument to each of the \fIkey\fR's in \fIargTable\fR. |
| \fBTk_ParseArgv\fR selects the first specifier whose \fIkey\fR matches |
| the argument exactly, if such a specifier exists. Otherwise |
| \fBTk_ParseArgv\fR selects a specifier for which the argument |
| is a unique abbreviation. If the argument is a unique abbreviation |
| for more than one specifier, then an error is returned. If there |
| is no matching entry in \fIargTable\fR, then the argument is |
| skipped and returned to the caller. |
| .PP |
| Once a matching argument specifier is found, \fBTk_ParseArgv\fR |
| processes the argument according to the \fItype\fR field of the |
| specifier. The argument that matched \fIkey\fR is called ``the matching |
| argument'' in the descriptions below. As part of the processing, |
| \fBTk_ParseArgv\fR may also use the next argument in \fIargv\fR |
| after the matching argument, which is called ``the following |
| argument''. The legal values for \fItype\fR, and the processing |
| that they cause, are as follows: |
| .TP |
| \fBTK_ARGV_END\fR |
| Marks the end of the table. The last entry in \fIargTable\fR |
| must have this type; all of its other fields are ignored and it |
| will never match any arguments. |
| .TP |
| \fBTK_ARGV_CONSTANT\fR |
| \fISrc\fR is treated as an integer and \fIdst\fR is treated |
| as a pointer to an integer. \fISrc\fR is stored at \fI*dst\fR. |
| The matching argument is discarded. |
| .TP |
| \fBTK_ARGV_INT\fR |
| The following argument must contain an |
| integer string in the format accepted by \fBstrtol\fR (e.g. ``0'' |
| and ``0x'' prefixes may be used to specify octal or hexadecimal |
| numbers, respectively). \fIDst\fR is treated as a pointer to an |
| integer; the following argument is converted to an integer value |
| and stored at \fI*dst\fR. \fISrc\fR is ignored. The matching |
| and following arguments are discarded from \fIargv\fR. |
| .TP |
| \fBTK_ARGV_FLOAT\fR |
| The following argument must contain a floating-point number in |
| the format accepted by \fBstrtol\fR. |
| \fIDst\fR is treated as the address of an double-precision |
| floating point value; the following argument is converted to a |
| double-precision value and stored at \fI*dst\fR. The matching |
| and following arguments are discarded from \fIargv\fR. |
| .TP |
| \fBTK_ARGV_STRING\fR |
| In this form, \fIdst\fR is treated as a pointer to a (char *); |
| \fBTk_ParseArgv\fR stores at \fI*dst\fR a pointer to the following |
| argument, and discards the matching and following arguments from |
| \fIargv\fR. \fISrc\fR is ignored. |
| .TP |
| \fBTK_ARGV_UID\fR |
| This form is similar to TK_ARGV_STRING, except that the argument |
| is turned into a Tk_Uid by calling \fBTk_GetUid\fR. |
| \fIDst\fR is treated as a pointer to a |
| Tk_Uid; \fBTk_ParseArgv\fR stores at \fI*dst\fR the Tk_Uid |
| corresponding to the following |
| argument, and discards the matching and following arguments from |
| \fIargv\fR. \fISrc\fR is ignored. |
| .TP |
| \fBTK_ARGV_CONST_OPTION\fR |
| This form causes a Tk option to be set (as if the \fBoption\fR |
| command had been invoked). The \fIsrc\fR field is treated as a |
| pointer to a string giving the value of an option, and \fIdst\fR |
| is treated as a pointer to the name of the option. The matching |
| argument is discarded. If \fItkwin\fR is NULL, then argument |
| specifiers of this type are ignored (as if they did not exist). |
| .TP |
| \fBTK_ARGV_OPTION_VALUE\fR |
| 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 \fIsrc\fR. \fIDst\fR is used as the name of the option. |
| \fISrc\fR is ignored. The matching and following arguments |
| are discarded. If \fItkwin\fR is NULL, then argument |
| specifiers of this type are ignored (as if they did not exist). |
| .TP |
| \fBTK_ARGV_OPTION_NAME_VALUE\fR |
| 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 \fIsrc\fR and \fIdst\fR are ignored. All three |
| arguments are discarded from \fIargv\fR. If \fItkwin\fR is NULL, |
| then argument |
| specifiers of this type are ignored (as if they did not exist). |
| .TP |
| \fBTK_ARGV_HELP\fR |
| When this kind of option is encountered, \fBTk_ParseArgv\fR uses the |
| \fIhelp\fR fields of \fIargTable\fR to format a message describing |
| all the valid arguments. The message is placed in \fIinterp->result\fR |
| and \fBTk_ParseArgv\fR returns TCL_ERROR. When this happens, the |
| caller normally prints the help message and aborts. If the \fIkey\fR |
| 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. |
| .TP |
| \fBTK_ARGV_REST\fR |
| 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 \fBTK_ARGV_REST\fR argument is found, then |
| \fBTk_ParseArgv\fR doesn't process any |
| of the remaining arguments; it returns them all at |
| the beginning of \fIargv\fR (along with any other unprocessed arguments). |
| In addition, \fBTk_ParseArgv\fR treats \fIdst\fR as the address of an |
| integer value, and stores at \fI*dst\fR the index of the first of the |
| \fBTK_ARGV_REST\fR options in the returned \fIargv\fR. This allows the |
| program to distinguish the \fBTK_ARGV_REST\fR options from other |
| unprocessed options that preceded the \fBTK_ARGV_REST\fR. |
| .TP |
| \fBTK_ARGV_FUNC\fR |
| For this kind of argument, \fIsrc\fR is treated as the address of |
| a procedure, which is invoked to process the following argument. |
| The procedure should have the following structure: |
| .RS |
| .CS |
| int |
| \fIfunc\fR(\fIdst\fR, \fIkey\fR, \fInextArg\fR) |
| char *\fIdst\fR; |
| char *\fIkey\fR; |
| char *\fInextArg\fR; |
| { |
| } |
| .CE |
| The \fIdst\fR and \fIkey\fR parameters will contain the |
| corresponding fields from the \fIargTable\fR entry, and |
| \fInextArg\fR will point to the following argument from \fIargv\fR |
| (or NULL if there aren't any more arguments left in \fIargv\fR). |
| If \fIfunc\fR uses \fInextArg\fR (so that |
| \fBTk_ParseArgv\fR should discard it), then it should return 1. Otherwise it |
| should return 0 and \fBTkParseArgv\fR will process the following |
| argument in the normal fashion. In either event the matching argument |
| is discarded. |
| .RE |
| .TP |
| \fBTK_ARGV_GENFUNC\fR |
| This form provides a more general procedural escape. It treats |
| \fIsrc\fR as the address of a procedure, and passes that procedure |
| all of the remaining arguments. The procedure should have the following |
| form: |
| .RS |
| .CS |
| int |
| \fIgenfunc\fR(dst, interp, key, argc, argv) |
| char *\fIdst\fR; |
| Tcl_Interp *\fIinterp\fR; |
| char *\fIkey\fR; |
| int \fIargc\fR; |
| char **\fIargv\fR; |
| { |
| } |
| .CE |
| The \fIdst\fR and \fIkey\fR parameters will contain the |
| corresponding fields from the \fIargTable\fR entry. \fIInterp\fR |
| will be the same as the \fIinterp\fR argument to \fBTcl_ParseArgv\fR. |
| \fIArgc\fR and \fIargv\fR refer to all of the options after the |
| matching one. \fIGenfunc\fR should behave in a fashion similar |
| to \fBTk_ParseArgv\fR: parse as many of the remaining arguments as it can, |
| then return any that are left by compacting them to the beginning of |
| \fIargv\fR (starting at \fIargv\fR[0]). \fIGenfunc\fR |
| should return a count of how many arguments are left in \fIargv\fR; |
| \fBTk_ParseArgv\fR will process them. If \fIgenfunc\fR encounters |
| an error then it should leave an error message in \fIinterp->result\fR, |
| in the usual Tcl fashion, and return -1; when this happens |
| \fBTk_ParseArgv\fR will abort its processing and return TCL_ERROR. |
| .RE |
| |
| .SH "FLAGS" |
| .TP |
| \fBTK_ARGV_DONT_SKIP_FIRST_ARG\fR |
| \fBTk_ParseArgv\fR normally treats \fIargv[0]\fR as a program |
| or command name, and returns it to the caller just as if it |
| hadn't matched \fIargTable\fR. If this flag is given, then |
| \fIargv[0]\fR is not given special treatment. |
| .TP |
| \fBTK_ARGV_NO_ABBREV\fR |
| Normally, \fBTk_ParseArgv\fR accepts unique abbreviations for |
| \fIkey\fR values in \fIargTable\fR. If this flag is given then |
| only exact matches will be acceptable. |
| .TP |
| \fBTK_ARGV_NO_LEFTOVERS\fR |
| Normally, \fBTk_ParseArgv\fR returns unrecognized arguments to the |
| caller. If this bit is set in \fIflags\fR then \fBTk_ParseArgv\fR |
| will return an error if it encounters any argument that doesn't |
| match \fIargTable\fR. The only exception to this rule is \fIargv[0]\fR, |
| which will be returned to the caller with no errors as |
| long as TK_ARGV_DONT_SKIP_FIRST_ARG isn't specified. |
| .TP |
| \fBTK_ARGV_NO_DEFAULTS\fR |
| Normally, \fBTk_ParseArgv\fR searches an internal table of |
| standard argument specifiers in addition to \fIargTable\fR. If |
| this bit is set in \fIflags\fR, then \fBTk_ParseArgv\fR will |
| use only \fIargTable\fR and not its default table. |
| |
| .SH EXAMPLE |
| .PP |
| Here is an example definition of an \fIargTable\fR and |
| some sample command lines that use the options. Note the effect |
| on \fIargc\fR and \fIargv\fR; arguments processed by \fBTk_ParseArgv\fR |
| are eliminated from \fIargv\fR, and \fIargc\fR |
| is updated to reflect reduced number of arguments. |
| .CS |
| /* |
| * 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\en", interp->result); |
| exit(1); |
| } |
| |
| /* |
| * Remainder of the program. |
| */ |
| } |
| .CE |
| .PP |
| Note that default values can be assigned to variables named in |
| \fIargTable\fR: the variables will only be overwritten if the |
| particular arguments are present in \fIargv\fR. |
| Here are some example command lines and their effects. |
| .CS |
| 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 |
| .CE |
| In all of the above examples, \fIargc\fR will be set by \fBTk_ParseArgv\fR to 2, |
| \fIargv\fR[0] will be ``prog'', \fIargv\fR[1] will be ``infile'', |
| and \fIargv\fR[2] will be NULL. |
| |
| .SH KEYWORDS |
| arguments, command line, options |