Usenet 1994 October

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume19 / parseargs / patch05b < prev next >

Wrap

Text File | 1991-05-17 | 55.4 KB | 1,393 lines

Newsgroups: comp.sources.misc From: Brad Appleton <brad@hcx1.ssd.csd.harris.com> Subject: v19i083: parseargs - functions to parse command line argument, Patch05b/5 Message-ID: <1991May17.181553.22245@sparky.IMD.Sterling.COM> X-Md4-Signature: 6a3c5a65019a2489257cc48e9e7ecaab Date: Fri, 17 May 1991 18:15:53 GMT Approved: kent@sparky.imd.sterling.com Submitted-by: Brad Appleton <brad@hcx1.ssd.csd.harris.com> Posting-number: Volume 19, Issue 83 Archive-name: parseargs/patch05b Patch-To: parseargs: Volume 17, Issue 45-57 #!/bin/sh # do not concatenate these parts, unpack them in order with /bin/sh # file PATCH05 continued # if test ! -r _shar_seq_.tmp; then echo 'Please unpack part 1 first!' exit 1 fi (read Scheck if test "$Scheck" != 2; then echo Please unpack part "$Scheck" next! exit 1 else exit 0 fi ) < _shar_seq_.tmp || exit 1 if test ! -f _shar_wnt_.tmp; then echo 'x - still skipping PATCH05' else echo 'x - continuing file PATCH05' sed 's/^X//' << 'SHAR_EOF' >> 'PATCH05' && ! takes one parameter: the address of the first item in the arg-list. X .PP X An alternative to argument-lists is argument vectors (or arg-vectors). X Arg-vectors use the \s-1ARGVEC\s+1 flag instead of the \s-1ARGLIST\s+1 flag X and do not require a special \fIlistXxxx\fP function for each vector-type. X Each of the \fIargXxxx\fP functions is responsible for handling vectors of its ! type (although some \fIargXxx\fP functions such as the boolean types do not ! support vectors). An arg-vector is a structure which contains a count, an ! array of elements (i.e. an \f4argc,argv\fP pair), and an array of flags, ! one for each element of argv. There are two macros in defined in X \f4<parseargs.h>\fR which are used for arg-vectors. \s-1ARGVEC_T\s+1 may be X used to declare a vector structure or a vector type; X \s-1ARGVEC_EMPTY\s+1 may be used to initialize the structure. diff -cNr ../patchlevel4/doc/parseargs.man1 ./doc/parseargs.man1 *** ../patchlevel4/doc/parseargs.man1 Thu May 2 11:01:33 1991 --- ./doc/parseargs.man1 Thu May 2 14:35:21 1991 *************** *** 12,31 **** X .SH SYNOPSIS X .TP 12 X \fBparseargs\fP ! [\fB\-U\fP] ! [\fB\-M\fP] X [\fB\-T\fP\ \fIstring\fP] X [\fB\-F\fP\ \fIstring\fP] - [\fB\-A\fP] X [\fB\-a\fP\ \fIarg-spec\fP] X [\fB\-e\fP\ \fIname\fP] X [\fB\-f\fP\ \fIfile\fP] - [\fB\-l\fP] - [\fB\-o\fP] X [\fB\-s\fP\ \fIshell\fP\^] - [\fB\-u\fP] - [\fB\-i\fP] - [\fB\-p\fP] X \fB\-\^\-\fP X \fIname\fP X [\fIarguments\fP\ .\^.\^.\^] --- 12,25 ---- X .SH SYNOPSIS X .TP 12 X \fBparseargs\fP ! [\fB\-#UMCAlouip1\fP] ! [\fB\-S\fP\ \fIseparator\fP] X [\fB\-T\fP\ \fIstring\fP] X [\fB\-F\fP\ \fIstring\fP] X [\fB\-a\fP\ \fIarg-spec\fP] X [\fB\-e\fP\ \fIname\fP] X [\fB\-f\fP\ \fIfile\fP] X [\fB\-s\fP\ \fIshell\fP\^] X \fB\-\^\-\fP X \fIname\fP X [\fIarguments\fP\ .\^.\^.\^] *************** *** 32,37 **** --- 26,34 ---- X .\"----------------------------------------------------------- X .SH OPTIONS X .TP 14 + \fB\-#\fP + just print the version and patchlevel, do not parse the command line + .TP 14 X \fB\-U\fP X just print program usage, do not parse the command line X .TP 14 *************** *** 38,43 **** --- 35,43 ---- X \fB\-M\fP X just print (n|t)roff \-man manual page template, do not parse the command line X .TP 14 + \fB-S\fP\ \fIseparator\fP + field-separator-string used to delimit array elements (\fIdefault=``\0''\fP\|) + .TP 14 X \fB\-T\fP \fIstring\fP X string to use for true boolean arguments\| (\fIdefault=``\s-1TRUE\s+1\^''\fP\|) X .TP 14 *************** *** 44,49 **** --- 44,53 ---- X \fB\-F\fP \fIstring\fP X string to use for false boolean arguments (\fIdefault=``\^''\fP\|) X .TP 14 + \fB\-C\fP + Ignore the difference between upper and lower case when parsing single + character options. + .TP 14 X \fB\-A\fP X modify array behavior for the specified shell. X .TP 14 *************** *** 73,78 **** --- 77,86 ---- X .TP 14 X \fB\-i\fP X ignore bad command-line syntax and continue processing (instead of aborting) + .TP 14 + \fB\-1\fP + Force any and all non-positional parameters to be specified before any + positional parameters on the command-line. X .\"----------------------------------------------------------- X .SH ARGUMENTS X .TP 14 *************** *** 89,95 **** X .\"----------------------------------------------------------- X .PP X The argument specification string contains one entry for each possible flag. ! Entries in the arguments specification string are separated by commas. X Each entry has five comma-separated fields: X a name, some flags, a type, a variable-name, and a prompt. X Each of these fields are described below: --- 97,103 ---- X .\"----------------------------------------------------------- X .PP X The argument specification string contains one entry for each possible flag. ! Entries in the argument specification string are separated by commas. X Each entry has five comma-separated fields: X a name, some flags, a type, a variable-name, and a prompt. X Each of these fields are described below: *************** *** 110,134 **** X to indicate an optional argument X (\s-1ARGOPT\s+1 is the default unless \s-1ARGREQ\s+1 is specified). X \s-1ARGPOS\s+1 ! can be ``ored'' in to indicate a positional argument that may also X be keyword matched. - \s-1ARGNOVAL\s+1 - can be ``ored'' in to indicate that an argument is an option - or a keyword that does not use an accompanying argument (such as - a boolean flag). This flag is only required for corresponding argument - types that are implemented by the programmer; \fBparseargs\fP already - knows which pre-defined argument types take an argument. X \s-1ARGVALOPT\s+1 ! can be ``ored'' in to indicate that an argument to the option may be X optionally supplied on the command-line, but is not required. X \s-1ARGVALREQ\s+1 ! can be ``ored'' in to indicate that an argument to the option is required X (this is the default behavior for options that take arguments). X \s-1ARGLIST\s+1 ! can be ``ored'' in (using the `\^|\^' character) to indicate that an argument X is actually a list of one or more arguments from the command line. X \s-1ARGHIDDEN\s+1 ! can be ``ored'' in to indicate a flag that should not be printed X in usage messages \(em X for example, flags intended for internal debugging purposes. X .TP 10 --- 118,136 ---- X to indicate an optional argument X (\s-1ARGOPT\s+1 is the default unless \s-1ARGREQ\s+1 is specified). X \s-1ARGPOS\s+1 ! may be ``ored'' in to indicate a positional argument that may also X be keyword matched. X \s-1ARGVALOPT\s+1 ! may be ``ored'' in to indicate that an argument to the option may be X optionally supplied on the command-line, but is not required. X \s-1ARGVALREQ\s+1 ! may be ``ored'' in to indicate that an argument to the option is required X (this is the default behavior for options that take arguments). X \s-1ARGLIST\s+1 ! may be ``ored'' in (using the `\^|\^' character) to indicate that an argument X is actually a list of one or more arguments from the command line. X \s-1ARGHIDDEN\s+1 ! may be ``ored'' in to indicate a flag that should not be printed X in usage messages \(em X for example, flags intended for internal debugging purposes. X .TP 10 *************** *** 175,181 **** X to the script if there is a limit to the number of arguments and/or characters X that may appear on the command line. X For this reason, the argument specification string may be stored: in an ! environment variable using the \fB-e\fP \fIname\fP option; in a file X and read using the \fB\-f\fP \fIfile\fP option; or read from standard input. X When using the \fB\-e\fP option, the user must remember to use the name X of an environment variable (not a mere shell variable)! --- 177,183 ---- X to the script if there is a limit to the number of arguments and/or characters X that may appear on the command line. X For this reason, the argument specification string may be stored: in an ! environment variable using the \fB\-e\fP \fIname\fP option; in a file X and read using the \fB\-f\fP \fIfile\fP option; or read from standard input. X When using the \fB\-e\fP option, the user must remember to use the name X of an environment variable (not a mere shell variable)! *************** *** 191,197 **** X The default behavior of parseargs is to allow both single-character options and X long-options (keywords) on the command-line. The user may specify that only X options (long-options) are to be permitted by specifying the \fB\-o\fP ! (\fB\-l\) option on the command-line. X .\"---------------------------------------------------------------- X .so argvalopt.inc X .\"---------------------------------------------------------------- --- 193,213 ---- X The default behavior of parseargs is to allow both single-character options and X long-options (keywords) on the command-line. The user may specify that only X options (long-options) are to be permitted by specifying the \fB\-o\fP ! (\fB\-l\fP) option on the command-line. ! .\"---------------------------------------------------------------- ! .SH "SPECIFYING PARSE-BEHAVIOR" ! .PP ! The \fB\-C\fP, \fB\-p\fP, \fB\-i\fP, and \fB\-1\fP switches may be used to ! modify the command-line parsing behavior of the invoking script. Specifying ! \fB\-C\fP will cause case-differences in single-character options to be ! ignored. Specifying \fB\-p\fP will cause the user to be interactively prompted ! for any missing required arguments. Specifying \fB\-i\fP will cause ! syntactically incorrect arguments to be ignored (instead of having a usage ! message printed and execution terminated). Specifying \fB\-1\fP will force ! all non-positional parameters to precede any positional parameters on the ! command-line (hence anything on the command-line after a positional parameter ! that resembles a keyword parameter will nevertheles be interpreted as a ! positional parameter). X .\"---------------------------------------------------------------- X .so argvalopt.inc X .\"---------------------------------------------------------------- *************** *** 227,233 **** X ENDOFARGS X " X .sp 8p ! eval `echo "$ARGUMENTS" | parseargs \-s sh \-\|\- $0 "$@"` X .sp 8p X .ft R X .fi --- 243,249 ---- X ENDOFARGS X " X .sp 8p ! eval `echo "$ARGSPEC" | parseargs \-s sh \-\|\- $0 "$@"` X .sp 8p X .ft R X .fi *************** *** 300,308 **** X Normal exit status (no problems were encountered). X .TP 5 X \|\|1 ! The calling program specified the \fB\-U\fP or the \fB\-M\fP option to ! \fBparseargs\fP, or specified an \fIargUsage\fP flag on the command line. ! Only the appropriate message is displayed. X .TP 5 X \|\|2 X A command line syntax error was encountered by \fBparseargs\fP. The offending --- 316,324 ---- X Normal exit status (no problems were encountered). X .TP 5 X \|\|1 ! The calling program specified the \fB\-#\fP, the \fB\-U\fP or the \fB\-M\fP ! option to \fBparseargs\fP, or specified an \fIargUsage\fP flag on the command ! line. Only the appropriate message is displayed. X .TP 5 X \|\|2 X A command line syntax error was encountered by \fBparseargs\fP. The offending diff -cNr ../patchlevel4/doc/parseargs.man3 ./doc/parseargs.man3 *** ../patchlevel4/doc/parseargs.man3 Thu May 2 11:01:45 1991 --- ./doc/parseargs.man3 Thu May 2 14:35:24 1991 *************** *** 2,19 **** X .TH PARSEARGS 3 X .\"----------------------------------------------------------- X .SH NAME ! parseargs, usage \- parse command line argument vectors X .\"----------------------------------------------------------- X .SH SYNOPSIS X #include <parseargs.h> X .PP X .nf ! int parseargs( char *argv[], ARGDESC *argd ) ! int fparseargs( FILE *fp, ARGDESC *argd ) ! int lparseargs( ArgList *argls, ARGDESC *argd ) ! int sparseargs( char *str, ARGDESC *argd ) ! int vparseargs( ARGDESC *argd, int argc, ... ) ! void usage( const ARGDESC *argd ) X .fi X .\"----------------------------------------------------------- X .SH DESCRIPTION --- 2,20 ---- X .TH PARSEARGS 3 X .\"----------------------------------------------------------- X .SH NAME ! parseargs \- parse command line argument vectors X .\"----------------------------------------------------------- X .SH SYNOPSIS X #include <parseargs.h> X .PP X .nf ! int parseargs( char *argv\f4[]\fP, ARGDESC *argd ); ! int fparseargs( FILE *fp, ARGDESC *argd ); ! int lparseargs( ArgList *argls, ARGDESC *argd ); ! int sparseargs( char *str, ARGDESC *argd ); ! int vparseargs( ARGDESC *argd, int argc, ... ); ! void usage( const ARGDESC *argd ); ! extern const char *ProgName; X .fi X .\"----------------------------------------------------------- X .SH DESCRIPTION *************** *** 23,28 **** --- 24,34 ---- X .so sparseargs3.inc X .so vparseargs3.inc X .so usage3.inc + .PP + After returning from any of the aforementioned functions, the global + string \fIProgName\fP will contain the name of the command corresponding + to the argument-descriptor array that was most recently operated upon by + one the functions in the \fIparseargs\fP(3) function library. X .\"----------------------------------------------------------- X .so argdesc.inc X .\"----------------------------------------------------------- *************** *** 42,48 **** X char *InFile; X char *OutFile = CHARNULL; X BOOL XRated = FALSE; ! struct namelist *Files = NULL; X X ARGDESC Args[] = X { --- 48,54 ---- X char *InFile; X char *OutFile = CHARNULL; X BOOL XRated = FALSE; ! ArgList *Files = ARGLISTNULL; X X ARGDESC Args[] = X { *************** *** 52,58 **** X ' ', ARGREQ, argStr, _\|_ &InFile, "INPUTfile {input file}", X ' ', ARGOPT, argStr, _\|_ &OutFile, "OUTPUTfile {output file}", X 'X', ARGHIDDEN, argBool, _\|_ &XRated, "XratedMODE {naughty stuff!}", ! ' ', ARGOPT\^|\^ARGLIST, argStr, _\|_ &Files, "File {files to be read}", X ENDOFARGS X }; X .ft R --- 58,64 ---- X ' ', ARGREQ, argStr, _\|_ &InFile, "INPUTfile {input file}", X ' ', ARGOPT, argStr, _\|_ &OutFile, "OUTPUTfile {output file}", X 'X', ARGHIDDEN, argBool, _\|_ &XRated, "XratedMODE {naughty stuff!}", ! ' ', ARGLIST, listStr, _\|_ &Files, "File {files to be read}", X ENDOFARGS X }; X .ft R *************** *** 116,158 **** X .fi X .RE X .PP ! The ! .I argd ! argument points to the descriptor for the argument being converted. ! Its main use is to find the location in which to store the converted value, ! located in argd\(->ad_valp. ! The string value to be converted is passed in ! .IR vp X (which will be \s-1NULL\s+1 if the \s-1ARGNOVAL\s+1 flag was set for the X corresponding entry in the arg-descriptor table). ! The ! .I copyf ! flag is TRUE if the ! .I vp ! string value must be copied when saved. ! Most non-string types are copied implicitly ! (for example, integer arguments are stored in binary form, ! so the original string value need not be saved), ! so this argument can usually be ignored. ! Put simply, this flag is ! TRUE ! when ! .I vp ! points to a temporary buffer area. ! .PP ! If the type function successfully converts the value, ! and uses the entire value, ! it should return TRUE. ! If the type function successfully converts the value, ! and uses only \fIN\fP characters of the value, ! it should return -\fIN\fP. ! Otherwise, ! it should print a message using X .IR usrerr (3) X and return FALSE. This message should be of the form X \fB"invalid xxxx option 'yyyy' for Zzzz"\fP, where xxxx is the type of the ! option, yyyy is the string passed in vp, and zzzz is the name (taken from ! \fBad\(->ad_prompt\fP). X The \fIargXxxx\fP function is responsible for detecting if the given argument X descriptor is an \s-1ARGVEC\s+1 argument and for taking the appropriate action. X .PP --- 122,148 ---- X .fi X .RE X .PP ! The \f4ad\fP argument points to the descriptor for the argument being ! converted. Its main use is to find the location in which to store the ! converted value, located in ad\(->ad_valp. ! The string value to be converted is passed in \f4vp\fP X (which will be \s-1NULL\s+1 if the \s-1ARGNOVAL\s+1 flag was set for the X corresponding entry in the arg-descriptor table). ! The \f4copyf\fP flag is TRUE if the \f4vp\fP string value must be copied ! when saved. Most non-string types are copied implicitly (for example, ! integer arguments are stored in binary form, so the original string value ! need not be saved), so this argument can usually be ignored. Put simply, ! this flag is TRUE when \f4vp\fP points to a temporary buffer area. ! .PP ! If the type function successfully converts the value, and uses the entire ! value, it should return TRUE. If the type function successfully converts ! the value, and uses only \fIN\fP characters of the value, it should return ! -\fIN\fP. Otherwise, it should print a message using X .IR usrerr (3) X and return FALSE. This message should be of the form X \fB"invalid xxxx option 'yyyy' for Zzzz"\fP, where xxxx is the type of the ! option, yyyy is the string passed in \f4vp\fP, and zzzz is the name (taken ! from \f4ad\(->ad_prompt\fP). X The \fIargXxxx\fP function is responsible for detecting if the given argument X descriptor is an \s-1ARGVEC\s+1 argument and for taking the appropriate action. X .PP *************** *** 204,215 **** X .\"------------------------------------------------------------------ X .SH LONG OPTIONS X .PP ! Under \s-1UNIX\s+1, Parseargs also allows for long options in addition to ! single character options. Long options are denoted by a `\fB+\fP' character ! (which may be changed using \fIkeywordprefix\fP). The keyword that is ! used is the first word in the prompt field of an argument descriptor entry. ! Long options are case insensitive! An argument to a long option may be ! separated from the long option by an equal sign (`=') or by one or more X whitespace characters. Thus, if an entry looks like: X .RS X .sp 4p --- 194,211 ---- X .\"------------------------------------------------------------------ X .SH LONG OPTIONS X .PP ! Under \s-1UNIX\s+1, \s-1MS-DOS\s+1, and \s-1OS\s+1/2, ! \fIparseargs\fP also allows for long ! options in addition to single character options. ! Under \s-1UNIX\s+1, long options are denoted by a `\fB+\fP' character. ! Under \s-1MS-DOS\s+1, and \s-1OS\s+1/2, long options are denoted by the second ! character in the \s-1SWITCHAR\s+1 environment variable. If there is no second ! character, then if the first character is `\-', then a `\fB+\fP' is used, ! otherwise a `\fB/\fP' is used. ! The keyword that is used is the first word in the prompt field of an ! argument descriptor entry. Long options are case insensitive! ! Under \s-1UNIX\s+1, an argument to a long option may be separated ! from the long option by an equal sign (`=') or by one or more X whitespace characters. Thus, if an entry looks like: X .RS X .sp 4p *************** *** 225,234 **** X .PP X The long option names for ``\fB\-?\fP'' in the default argument descriptor X are ``\fB+help\fP'' and ``\fB+?\fP'' (respectively). In addition, ``\fB++\fP'' ! or ``\fB+endopts\fP'' may be used to indicate the end of options so that X all remaining arguments will be interpreted as positional parameters X (even if one begins with a `\fB+\fP' or a `\fB\-\fP'). X .PP X Under VAX/VMS and AmigaDOS, single-character options are not used and the X ``long'' name (in the prompt field of an argument descriptor) is always used X to match for possible arguments (or keywords, or qualifiers). --- 221,236 ---- X .PP X The long option names for ``\fB\-?\fP'' in the default argument descriptor X are ``\fB+help\fP'' and ``\fB+?\fP'' (respectively). In addition, ``\fB++\fP'' ! may be used to indicate the end of options so that X all remaining arguments will be interpreted as positional parameters X (even if one begins with a `\fB+\fP' or a `\fB\-\fP'). X .PP + Under \s-1MS-DOS\s+1, and \s-1OS\s+1/2, an argument to a long-option must be + separated from the long option by an equal sign (`=') (unless the first + character of $SWITCHAR is a `\-', in which case \s-1UNIX\s+1 syntax is used). + The long option names for ``\fB/?\fP'' in the default argument descriptor + are ``\fB/help\fP'' and ``\fB/?\fP'' (respectively). + .PP X Under VAX/VMS and AmigaDOS, single-character options are not used and the X ``long'' name (in the prompt field of an argument descriptor) is always used X to match for possible arguments (or keywords, or qualifiers). *************** *** 238,244 **** X match all characters in the prompt field (as in ``\fB+count=4\fP'' and X ``\fB+repcount=4\fP''). X .PP ! Under \s-1UNIX\s+1 and \s-1VAX/VMS\s+1, X only the number of characters required to uniquely identify the desired argument X are needed, but at least two characters must be given (unless the prompt field X is itself less than two characters long). This means that using the above --- 240,246 ---- X match all characters in the prompt field (as in ``\fB+count=4\fP'' and X ``\fB+repcount=4\fP''). X .PP ! Under all systems except AmigaDOS, X only the number of characters required to uniquely identify the desired argument X are needed, but at least two characters must be given (unless the prompt field X is itself less than two characters long). This means that using the above *************** *** 255,264 **** X .\"------------------------------------------------------------------ X .so returns.inc X .\"------------------------------------------------------------------ X .SH SEE ALSO X .IR argtype (3), X .IR parseargs (1), ! .IR syserr (3) X .br X The ``C Advisor'' column in X .ul --- 257,287 ---- X .\"------------------------------------------------------------------ X .so returns.inc X .\"------------------------------------------------------------------ + .so effects.inc + .\"------------------------------------------------------------------ + .SH "DOCUMENTING YOUR COMMANDS" + .PP + The commands that you write with \fIparseargs\fP(3) may be documented + using \fIparseargs\fP(1). Just copy the argument descriptor array + into a separate file, and invoke \fIparseargs\fP(1) with the \fB\-M\fP + option and pass it the command-name (dont forget to redirect input + to come from your newly created file). It is important to note that the + only portion of that argdesc array to insert into your file is the portion + starting with the very first command-line argument, all the way down to + (and including) the \s-1ENDOFARGS\s+1 or \s-1END_ARGUMENTS\s+1 entry. + .\"------------------------------------------------------------------ + .SH FILES + .IP "\fI/usr/local/lib/libparse.a\fP" + Link library for parseargs. + .IP "\fI/usr/local/include/parseargs.h\fP" + Include file for parseargs. + .IP "\fI/usr/local/include/useful.h\fP" + Include file for portability. + .\"------------------------------------------------------------------ X .SH SEE ALSO X .IR argtype (3), X .IR parseargs (1), ! .IR parsecntl (3) X .br X The ``C Advisor'' column in X .ul diff -cNr ../patchlevel4/doc/parseargs1.inc ./doc/parseargs1.inc *** ../patchlevel4/doc/parseargs1.inc Thu May 2 11:01:54 1991 --- ./doc/parseargs1.inc Thu May 2 14:35:28 1991 *************** *** 28,32 **** X Given the command name and the argument specification string, X .B parseargs \-M X prints a template of the command-syntax on standard output that is ! suitable for input to \fInroff\fP or \fItroff\fP using the \-man X macro package. --- 28,37 ---- X Given the command name and the argument specification string, X .B parseargs \-M X prints a template of the command-syntax on standard output that is ! suitable for input to \fInroff\fP or \fItroff\fP using the \fI\-man\fP X macro package. + .PP + Given no other arguments + \fBparseargs \-#\fP prints on standard output, the current version and + patchlevel of the running version of \fBparseargs\fP. + diff -cNr ../patchlevel4/doc/parsecntl.man3 ./doc/parsecntl.man3 *** ../patchlevel4/doc/parsecntl.man3 Thu May 2 10:56:24 1991 --- ./doc/parsecntl.man3 Thu May 2 14:35:33 1991 *************** *** 8,14 **** X #include <parseargs.h> X .PP X .nf ! int parsecntl( ARGDESC argd[\|], parsecntl_t func, parsemode_t mode, ... ) X .fi X X .\"----------------------------------- --- 8,14 ---- X #include <parseargs.h> X .PP X .nf ! int parsecntl( ARGDESC argd[\|], parsecntl_t func, parsemode_t mode, ... ); X .fi X X .\"----------------------------------- *************** *** 24,35 **** X .\"----------------------------------- X .so returns.inc X .\"----------------------------------- X .SH SEE ALSO - .nf X .IR argtype (3), X .IR parseargs (3), X .IR parseargs (1) - .fi X .\"----------------------------------- X .SH AUTHOR X .PP --- 24,35 ---- X .\"----------------------------------- X .so returns.inc X .\"----------------------------------- + .so effects.inc + .\"----------------------------------- X .SH SEE ALSO X .IR argtype (3), X .IR parseargs (3), X .IR parseargs (1) X .\"----------------------------------- X .SH AUTHOR X .PP diff -cNr ../patchlevel4/doc/parsecntl3.inc ./doc/parsecntl3.inc *** ../patchlevel4/doc/parsecntl3.inc Thu May 2 10:56:24 1991 --- ./doc/parsecntl3.inc Thu May 2 14:35:36 1991 *************** *** 28,35 **** X then the desired attributes are copied into X the object pointed to by the last parameter. If the mode is X .I pc_\s-1WRITE\s+1, ! then the attributes from the last parameter are copied to the command- ! object. If mode is X .I pc_\s-1RDWR\s+1, X then the attributes pointed to by the last X parameter are copied to the command-object, and then the previous value --- 28,35 ---- X then the desired attributes are copied into X the object pointed to by the last parameter. If the mode is X .I pc_\s-1WRITE\s+1, ! then the attributes from the last parameter are copied to the ! command-object. If mode is X .I pc_\s-1RDWR\s+1, X then the attributes pointed to by the last X parameter are copied to the command-object, and then the previous value diff -cNr ../patchlevel4/doc/parsecntls.inc ./doc/parsecntls.inc *** ../patchlevel4/doc/parsecntls.inc Thu May 2 10:56:25 1991 --- ./doc/parsecntls.inc Thu May 2 14:35:38 1991 *************** *** 108,119 **** X .ft R X .fi X ! Note that in the above call to ! .IR parsecntl(3), ! that zero will be X returned upon success and non-zero upon failure. If pe_DEFARGS is ! returned, then cmd is already on common_args's list of defaults (and ! would result in an infinite loop while parsing). X .\"--------------------------------------------- X .IP "\fIpc_\s-1NAME\s+1\fP" X .IP "\fIpc_\s-1PURPOSE\s+1\fP" --- 108,117 ---- X .ft R X .fi X ! Note that in the above call to \fIparsecntl\fP\^(3), that zero will be X returned upon success and non-zero upon failure. If pe_DEFARGS is ! returned, then \f4cmd\fP is already on \f4common_args\fP's list of defaults ! (and would result in an infinite loop while parsing). X .\"--------------------------------------------- X .IP "\fIpc_\s-1NAME\s+1\fP" X .IP "\fIpc_\s-1PURPOSE\s+1\fP" diff -cNr ../patchlevel4/doc/parseflags.inc ./doc/parseflags.inc *** ../patchlevel4/doc/parseflags.inc Thu May 2 10:56:25 1991 --- ./doc/parseflags.inc Thu May 2 14:35:40 1991 *************** *** 5,11 **** X .SH "PARSE FLAGS" X .PP X The following bitmasks may be combined in order to modify the ! behavior of the parseargs library. The parse flags for a given X may be set through the use of the \fIparsecntl\fP(3) function. X .\"--------------------------------------------- X .IP "\fIpa_\s-1PROMPT\s+1\fP" --- 5,11 ---- X .SH "PARSE FLAGS" X .PP X The following bitmasks may be combined in order to modify the ! behavior of the \fIparseargs\fP library. The parse flags for a given X may be set through the use of the \fIparsecntl\fP(3) function. X .\"--------------------------------------------- X .IP "\fIpa_\s-1PROMPT\s+1\fP" *************** *** 17,24 **** X .\"--------------------------------------------- X .IP "\fIpa_\s-1IGNORE\s+1\fP" X Ignore any unrecognized or improperly specified command-line arguments ! and continue execution of the program. Normally, if an argument is ! unmatched (or is improperly specified), a usage message is printed X program execution is terminated. X .\"--------------------------------------------- X .IP "\fIpa_\s-1OPTSONLY\s+1\fP" --- 17,24 ---- X .\"--------------------------------------------- X .IP "\fIpa_\s-1IGNORE\s+1\fP" X Ignore any unrecognized or improperly specified command-line arguments ! and continue execution of the program. Normally, if a required argument is ! unmatched (or an argument is improperly specified), a usage message is printed X program execution is terminated. X .\"--------------------------------------------- X .IP "\fIpa_\s-1OPTSONLY\s+1\fP" *************** *** 28,34 **** X .\"--------------------------------------------- X .IP "\fIpa_\s-1KWDSONLY\s+1\fP" X Under \s-1UNIX\s+1, setting this flag disables the parsing of single-character ! options. This will cause all arguments starting with `-' to always X be treated as a positional parameter (instead of an option). X .\"--------------------------------------------- X .IP "\fIpa_\s-1FLAGS1ST\s+1\fP" --- 28,34 ---- X .\"--------------------------------------------- X .IP "\fIpa_\s-1KWDSONLY\s+1\fP" X Under \s-1UNIX\s+1, setting this flag disables the parsing of single-character ! options. This will cause all arguments starting with `\-' to always X be treated as a positional parameter (instead of an option). X .\"--------------------------------------------- X .IP "\fIpa_\s-1FLAGS1ST\s+1\fP" *************** *** 47,70 **** X .IP "\fIpa_\s-1ANYCASE\s+1\fP" X Setting this flag will cause character-case to be ignored when attempting X to match single-character argument names (i.e. causes "\fB\-i\fP" and ! "\fB\-I\fP" will be considered equivalent). X .\"--------------------------------------------- X .IP "\fIpa_\s-1ARGV0\s+1\fP" ! Normally, the parseargs library will assume that the first argument ! on the command-line is the name of the command. Setting this flag ! tells parseargs that this is \s-1NOT\s+1 the case and that the very first X argument on the command-line is a bona-fide argument to the command. X .\"--------------------------------------------- X .IP "\fIpa_\s-1NOCHECK\s+1\fP" ! Setting this flag will prevent parseargs from checking for any X required arguments that were not given on the command-line. This ! is useful when more than one call to the parseargs library is needed X to parse all the command-line arguments (which could occur if the ! command-line argument came from a file or from two argv-vectors). X X Keeping this flag on until the final set of arguments is parsed will ! cause parseargs to not check for missing arguments until the last set ! of arguments has been parsed (by the final call to *parseargs). X .\"--------------------------------------------- X .IP "\fIpa_\s-1CONTINUE\s+1\fP" X Setting this flag will cause subsequent calls to the parseargs library --- 47,73 ---- X .IP "\fIpa_\s-1ANYCASE\s+1\fP" X Setting this flag will cause character-case to be ignored when attempting X to match single-character argument names (i.e. causes "\fB\-i\fP" and ! "\fB\-I\fP" to be considered equivalent). X .\"--------------------------------------------- X .IP "\fIpa_\s-1ARGV0\s+1\fP" ! Normally, the \fIparseargs\fP library will assume that the first argument ! on the command-line is the name of the command. Setting this flag tells ! \fIparseargs\fP that this is \s-1NOT\s+1 the case and that the very first X argument on the command-line is a bona-fide argument to the command. X .\"--------------------------------------------- X .IP "\fIpa_\s-1NOCHECK\s+1\fP" ! Setting this flag will prevent \fIparseargs\fP from checking for any X required arguments that were not given on the command-line. This ! is useful when more than one call to the \fIparseargs\fP library is needed X to parse all the command-line arguments (which could occur if the ! command-line argument came from a file or from two \f4argv\fP-vectors). ! When this flag is set, then each call to parseargs will check for missing ! required arguments (and will prompt the user for them if desired). X X Keeping this flag on until the final set of arguments is parsed will ! cause \fIparseargs\fP to not check for missing arguments until the last set ! of arguments has been parsed (by the final call to one of the functions ! in the \fIparseargs\fP library). X .\"--------------------------------------------- X .IP "\fIpa_\s-1CONTINUE\s+1\fP" X Setting this flag will cause subsequent calls to the parseargs library diff -cNr ../patchlevel4/doc/parsemodes.inc ./doc/parsemodes.inc *** ../patchlevel4/doc/parsemodes.inc Thu May 2 10:56:26 1991 --- ./doc/parsemodes.inc Thu May 2 14:35:43 1991 *************** *** 6,12 **** X .PP X \fIParsecntl\fP may be used to read current command attributes, write X (assign) new command attributes, or both. The mode argument to ! parsecntl determines the which of these three alternatives are X desired. If the programmer merely wishes to assign new attributes, X then invoking \fIparsecntl\fP in \fIpc_\s-1WRITE\s+1\fP mode and passing X the new attributes will do the job. If the programmer wishes simply to query --- 6,12 ---- X .PP X \fIParsecntl\fP may be used to read current command attributes, write X (assign) new command attributes, or both. The mode argument to ! parsecntl determines which of these three alternatives are X desired. If the programmer merely wishes to assign new attributes, X then invoking \fIparsecntl\fP in \fIpc_\s-1WRITE\s+1\fP mode and passing X the new attributes will do the job. If the programmer wishes simply to query *************** *** 21,24 **** X When \fIparsecntl\fP returns, then (assuming it returns 0) the desired X attributes will have been assigned and the object that contained the X new attribute settings will now contain the attribute settings that ! were in effect before \fIparsecntl\fP was invoked. --- 21,24 ---- X When \fIparsecntl\fP returns, then (assuming it returns 0) the desired X attributes will have been assigned and the object that contained the X new attribute settings will now contain the attribute settings that ! were in effect immediately before \fIparsecntl\fP was invoked. diff -cNr ../patchlevel4/doc/sh_arrays.inc ./doc/sh_arrays.inc *** ../patchlevel4/doc/sh_arrays.inc Thu May 2 11:01:59 1991 --- ./doc/sh_arrays.inc Thu May 2 14:35:48 1991 *************** *** 9,15 **** X setting up an argument list depends largely upon the syntax of shell X that was specified on the command line via the \fB\-s\fP option X (although \s-1ARGLIST\s+1 arguments are treated exactly the same as ! \s-1ARGVEC\s+1 arguments). X .\"--------------- X .SS "Resetting the Positional Parameters to an Argument List" X .PP --- 9,18 ---- X setting up an argument list depends largely upon the syntax of shell X that was specified on the command line via the \fB\-s\fP option X (although \s-1ARGLIST\s+1 arguments are treated exactly the same as ! \s-1ARGVEC\s+1 arguments). With the exception of \fIperl\fP which always ! uses a comma to separate array elements, all shells will use the string ! specified with the \fB\-S\fP option as the field separator between elements ! of an array (the default field separator is a space character). X .\"--------------- X .SS "Resetting the Positional Parameters to an Argument List" X .PP *************** *** 23,29 **** X (this way, the positional parameters will be unset if the associated list X of command line arguments is not encountered). X .PP ! Similarly for the C and TC shells, X if the variable name corresponding to the \s-1ARGLIST\s+1 argument is X ``\fBargv\fP'', then the positional parameters of the calling program X will be re-assigned to the contents of the argument list. --- 26,32 ---- X (this way, the positional parameters will be unset if the associated list X of command line arguments is not encountered). X .PP ! Similarly for the C & Z shells (\fIzsh, csh, tcsh, itcsh\fP), X if the variable name corresponding to the \s-1ARGLIST\s+1 argument is X ``\fBargv\fP'', then the positional parameters of the calling program X will be re-assigned to the contents of the argument list. *************** *** 109,117 **** X .RS X \f4set \-A save_parms "$@"\fP X .RE ! .SS "C and TC Shell Argument Lists" X .PP ! For the C and TC shells, \s-1ARGLIST\s+1 variables are treated as word-lists X and are assigned using the following syntax: X .sp 2p X .RS --- 112,121 ---- X .RS X \f4set \-A save_parms "$@"\fP X .RE ! .SS "C Shell Argument Lists" X .PP ! For the C shells (\fIcsh, tcsh, itcsh\fP), ! \s-1ARGLIST\s+1 variables are treated as word-lists X and are assigned using the following syntax: X .sp 2p X .RS *************** *** 120,126 **** X .sp 2p X The first item will be in \f4$name[1]\fP, the second item will be in X \f4$name[2]\fP, etc ..., and all items may be given by \f4$name\fP. ! Notice that Korn shell arrays start at index zero whereas C and TC shell X word-lists start at index one. X .SS "Bourne-Again Shell Argument Lists" X .PP --- 124,130 ---- X .sp 2p X The first item will be in \f4$name[1]\fP, the second item will be in X \f4$name[2]\fP, etc ..., and all items may be given by \f4$name\fP. ! Notice that Korn shell arrays start at index zero whereas C shell X word-lists start at index one. X .SS "Bourne-Again Shell Argument Lists" X .PP *************** *** 130,136 **** X .SS "Plan 9 Shell Argument Lists" X .PP X For the Plan 9 shell, if the associated variable name is not ``*'' then ! it is considered to be word-list and set using the following syntax: X .nf X .RS X .ft 4 --- 134,140 ---- X .SS "Plan 9 Shell Argument Lists" X .PP X For the Plan 9 shell, if the associated variable name is not ``*'' then ! it is considered to be a word-list and set using the following syntax: X .nf X .RS X .ft 4 *************** *** 138,145 **** X .ft R X .RE X .fi X .SS "Awk Argument Lists" ! For \fIawk\fP, if the \fB\-A\fP option is not given, then the output for thes X variable-list will be a line with the variable name, followed by a line with X each of the values (each value will be separated with the field separator X specified using the \fB\-S\fP option - which defaults to a space). --- 142,162 ---- X .ft R X .RE X .fi + .SS "Z Shell Argument Lists" + .PP + For the Z shell, \s-1ARGLIST\s+1 variables are treated as word-lists + and are assigned using the following syntax: + .sp 2p + .RS + \f4name = ( 'arg1' 'arg2'\fP \fI...\fP\f4 )\fP + .RE + .sp 2p + The first item will be in \f4$name[1]\fP, the second item will be in + \f4$name[2]\fP, etc ..., and all items may be given by \f4$name\fP. + Notice that Korn shell arrays start at index zero whereas Z and C shell + word-lists start at index one. X .SS "Awk Argument Lists" ! For \fIawk\fP, if the \fB\-A\fP option is not given, then the output for the X variable-list will be a line with the variable name, followed by a line with X each of the values (each value will be separated with the field separator X specified using the \fB\-S\fP option - which defaults to a space). *************** *** 154,160 **** X If the \fB\-A\fP option is given, then the associated variable is considered X the root name of an array. The ouput for the array X will consist of two lines for each item in the list (as in the following ! expample): X .nf X .RS X .ft 4 --- 171,177 ---- X If the \fB\-A\fP option is given, then the associated variable is considered X the root name of an array. The ouput for the array X will consist of two lines for each item in the list (as in the following ! example): X .nf X .RS X .ft 4 *************** *** 178,191 **** X .nf X .RS X .ft 4 ! @name=( arg1 , arg2 , ... ); X .ft R X .RE X .fi X .SS "A Final Note on Argument Lists" X .PP ! The word-lists used by the C shell, the arrays used by the Korn shell, the ! Plan 9 shell, \fIawk\fP, \fIperl\fP, and the positional parameters used by X all shells (if overwritten by \fBparseargs\fP) will preserve any \s-1IFS\s+1 X characters in their contents. That is to say that if an item in one of the X aforementioned multi-word lists contains any \s-1IFS\s+1 characters, it will --- 195,208 ---- X .nf X .RS X .ft 4 ! @name=( 'arg1' , 'arg2' , ... ); X .ft R X .RE X .fi X .SS "A Final Note on Argument Lists" X .PP ! The word-lists used by the C and Z shells, the arrays used by the Korn shell, ! the Plan 9 shell, \fIawk\fP, \fIperl\fP, and the positional parameters used by X all shells (if overwritten by \fBparseargs\fP) will preserve any \s-1IFS\s+1 X characters in their contents. That is to say that if an item in one of the X aforementioned multi-word lists contains any \s-1IFS\s+1 characters, it will diff -cNr ../patchlevel4/doc/shells.inc ./doc/shells.inc *** ../patchlevel4/doc/shells.inc Thu May 2 11:02:07 1991 --- ./doc/shells.inc Thu May 2 14:35:51 1991 *************** *** 15,23 **** X (not be evaluated by the shell) in the corresponding shell variable. X .PP X The \fB\-s\fP \fIshell\fP option may be used to tell \fBparseargs\fP which ! shell syntax to use. At present, \fBparseargs\fP only recognizes ! ``sh'', ``csh'', ``ksh'', ``tcsh'', ``bash'', ``rc'', ``awk'', and ``perl'' ! as valid command interpreters. \fIAwk\fP output is slightly different from X that of the other shells in that the actual variable settings are not X printed but each line of an associative array is printed (the first field X is the array index, the second is the value for that index). --- 15,40 ---- X (not be evaluated by the shell) in the corresponding shell variable. X .PP X The \fB\-s\fP \fIshell\fP option may be used to tell \fBparseargs\fP which ! shell syntax to use. At present, \fBparseargs\fP only recognizes the following ! shells as valid command-interpreters: ! ! .RS ! .nf ! sh ! bash ! ksh ! csh ! tcsh ! itcsh ! zsh ! rc ! awk ! perl ! .fi ! .RE ! ! .PP ! \fIAwk\fP output is slightly different from X that of the other shells in that the actual variable settings are not X printed but each line of an associative array is printed (the first field X is the array index, the second is the value for that index). diff -cNr ../patchlevel4/doc/sparseargs3.inc ./doc/sparseargs3.inc *** ../patchlevel4/doc/sparseargs3.inc Thu May 2 10:56:29 1991 --- ./doc/sparseargs3.inc Thu May 2 14:35:53 1991 *************** *** 4,15 **** X .\"---------------------------------------------------------------------------- X .PP X Given a single string and an argdesc array, \fIsparseargs\fP ! will parse arguments from a string in much the same manner as \fIparseargs\fP. X .I Sparseargs X will split the given string up into a vector of whitespace X separated tokens and then attempt to parse the resultant vector as ! if it were given as \fIargv[]\fP on the command-line. X NO special treatment is given to characters such as single-quotes, X double-quotes, or anything else. \fISparseargs\fP will always assume that X any whitespace characters are intended as argument separators. - --- 4,14 ---- X .\"---------------------------------------------------------------------------- X .PP X Given a single string and an argdesc array, \fIsparseargs\fP ! will parse arguments from a string in much the manner as \fIparseargs\fP. X .I Sparseargs X will split the given string up into a vector of whitespace X separated tokens and then attempt to parse the resultant vector as ! if it were given as \f4argv[]\fP on the command-line. X NO special treatment is given to characters such as single-quotes, X double-quotes, or anything else. \fISparseargs\fP will always assume that X any whitespace characters are intended as argument separators. diff -cNr ../patchlevel4/doc/vparseargs3.inc ./doc/vparseargs3.inc *** ../patchlevel4/doc/vparseargs3.inc Thu May 2 10:56:30 1991 --- ./doc/vparseargs3.inc Thu May 2 14:35:58 1991 *************** *** 6,12 **** X .I Vparseargs X takes an argdesc array, the number of arguments to parse, and a X (possibly NULL terminated) list of argument-strings ! and parses them in much the same manner as \fIparseargs\fP. X Unlike X .I sparseargs, X .I vparseargs --- 6,12 ---- X .I Vparseargs X takes an argdesc array, the number of arguments to parse, and a X (possibly NULL terminated) list of argument-strings ! and parses them in the same manner as \fIparseargs\fP. X Unlike X .I sparseargs, X .I vparseargs *************** *** 13,16 **** X assumes that all parameters are already split up into tokens, hence any X whitespace characters contained in any of the string-parameters are used as X is (and will be considered a part of an argument name or value). - --- 13,15 ---- diff -cNr ../patchlevel4/ibm_args.c ./ibm_args.c *** ../patchlevel4/ibm_args.c Thu May 2 11:06:08 1991 --- ./ibm_args.c Thu May 2 14:36:02 1991 *************** *** 208,213 **** --- 208,214 ---- X get_prefixes(); X X while ( av && (p = *av++) ) { + /* is this a keyword */ X if ( isKWD(p) && X ( (OptPrefix != KwdPrefix) || *(p+2) && !strchr(s_ARG_SEP, *(p+2)) ) X ) { *************** *** 251,256 **** --- 252,262 ---- X continue; X } X + /* reset the argument flags - if this arg was already given, some + ** of its flags may be set to indicate how it was given before. + ** we need to know how it was given now (but save the old ones + ** just in case the new one fails). + */ X flags = arg_flags(ad); X if ( ARG_isGIVEN(ad) ) { X BCLEAR( arg_flags(ad), ARGVALSEP | ARGKEYWORD ); *************** *** 260,266 **** X BSET( arg_flags(ad), ARGKEYWORD ); X X if( ARG_isMULTIVAL(ad) ) { ! cmd_list(cmd) = ad; X } X else { X cmd_list(cmd) = ARGDESCNULL; --- 266,272 ---- X BSET( arg_flags(ad), ARGKEYWORD ); X X if( ARG_isMULTIVAL(ad) ) { ! cmd_list(cmd) = ad; /* we matched a lst or a vector */ X } X else { X cmd_list(cmd) = ARGDESCNULL; *************** *** 330,337 **** X continue; X } X ! /* flag argument */ ! while (*p) { X X /* find the flag in the list */ X is_match = FALSE; --- 336,348 ---- X continue; X } X ! /* We have a flag argument; ! ** remember that in the case of single character keywords, ! ** the conversion function (ad_type) tells us how many characters ! ** were used. We need that information to decide how many ! ** characters to skip before the next iteration of the while loop. ! */ ! while (*p) { /* while not end of switch-chars */ X X /* find the flag in the list */ X is_match = FALSE; *************** *** 363,368 **** --- 374,384 ---- X continue; X }/* if unknown-option */ X + /* reset the argument flags - if this arg was already given, some + ** of its flags may be set to indicate how it was given before. + ** we need to know how it was given now (but save the old ones + ** just in case the new one fails). + */ X flags = arg_flags(ad); X if ( ARG_isGIVEN(ad) ) { X BCLEAR( arg_flags(ad), ARGVALSEP | ARGKEYWORD ); *************** *** 370,376 **** X } X X if ( ARG_isMULTIVAL(ad) ) { ! cmd_list(cmd) = ad; X } X else { X cmd_list(cmd) = ARGDESCNULL; --- 386,392 ---- X } X X if ( ARG_isMULTIVAL(ad) ) { ! cmd_list(cmd) = ad; /* we matched a list (or a vector) */ X } X else { X cmd_list(cmd) = ARGDESCNULL; *************** *** 448,456 **** X }/*elif option*/ X else { X /* parsing a list of arguments */ ! if ( cmd_list(cmd) ) { X ad = cmd_list(cmd); ! flags = arg_flags(ad); X if ( ARG_isGIVEN(ad) ) { X BCLEAR( arg_flags(ad), ARGVALSEP | ARGKEYWORD ); X } --- 464,472 ---- X }/*elif option*/ X else { X /* parsing a list of arguments */ ! if ( cmd_list(cmd) ) { /* we're in the middle of a list/vector */ X ad = cmd_list(cmd); ! flags = arg_flags(ad); /* reset flags for this argv-item */ X if ( ARG_isGIVEN(ad) ) { X BCLEAR( arg_flags(ad), ARGVALSEP | ARGKEYWORD ); X } *************** *** 495,500 **** --- 511,517 ---- X cmd_list(cmd) = ad; X } X + /* if FLAGS1ST is set then first positional marks end-of-flags */ X if ( BTEST(cmd_flags(cmd), pa_FLAGS1ST) ) { X BSET( cmd_state(cmd), ps_NOFLAGS ); X } diff -cNr ../patchlevel4/parseargs.c ./parseargs.c *** ../patchlevel4/parseargs.c Thu May 2 11:06:09 1991 --- ./parseargs.c Thu May 2 14:36:12 1991 *************** *** 1,13 **** X /************************************************************************* X ** ^FILE: parseargs.c - command line interface to parseargs() X ** - ** ^DESCRIPTION: X ** This file implements the command-line interface to the parseargs X ** library. Under Unix, the user may use parseargs(1) (this program) X ** to parse command-line arguments for shell scripts. At the present, X ** time, VMS/DCL is not yet supported (nor are MS-DOS Batch-files). X ** ! ** X ** Given a command name, a vector of string-valued arguments such as that X ** passed to a shell script, and a specification string describing the X ** possible arguments, parseargs matches actual arguments to possible --- 1,12 ---- X /************************************************************************* X ** ^FILE: parseargs.c - command line interface to parseargs() X ** X ** This file implements the command-line interface to the parseargs X ** library. Under Unix, the user may use parseargs(1) (this program) X ** to parse command-line arguments for shell scripts. At the present, X ** time, VMS/DCL is not yet supported (nor are MS-DOS Batch-files). X ** ! ** ^DESCRIPTION: X ** Given a command name, a vector of string-valued arguments such as that X ** passed to a shell script, and a specification string describing the X ** possible arguments, parseargs matches actual arguments to possible *************** *** 158,176 **** X X /************************************************************************** X ** ^SECTION: SHELLS ! ** After the command line has been parsed, parseargs will print on stan- ! ** dard output, a script to set the shell variables which correspond to ! ** arguments that were present on the command-line. This script may be ! ** evaluated by redirecting it to a file and then executing the file, X ** or by directly evaluating the output from parseargs (under most UNIX ! ** shells, this could be done using eval). If any arguments on the com- ! ** mand line contained any special characters that needed to be escaped ! ** from the shell, these characters will remain intact (not be evaluated ! ** by the shell) in the corresponding shell variable. X ** X ** The -s shell option may be used to tell parseargs which shell syntax ! ** to use. At present, parseargs only recognizes "sh", "csh", "ksh", ! ** "tcsh", "bash", "rc", "awk", and "perl" as valid command interpreters. X ** Awk output is slightly different from that of the other shells in that X ** the actual variable settings are not printed but each line of an X ** associative array is printed (the first field is the array index, the --- 157,187 ---- X X /************************************************************************** X ** ^SECTION: SHELLS ! ** After the command line has been parsed, parseargs will print on ! ** standard output, a script to set the shell variables which correspond ! ** to arguments that were present on the command-line. This script may ! ** be evaluated by redirecting it to a file and then executing the file, X ** or by directly evaluating the output from parseargs (under most UNIX ! ** shells, this could be done using eval). If any arguments on the ! ** command line contained any special characters that needed to be ! ** escaped from the shell, these characters will remain intact (not be ! ** evaluated by the shell) in the corresponding shell variable. X ** X ** The -s shell option may be used to tell parseargs which shell syntax ! ** to use. At present, parseargs only recognizes the following shells as ! ** valid command-interpreters: ! ** ! ** sh ! ** bash ! ** ksh ! ** csh ! ** tcsh ! ** itcsh ! ** zsh ! ** rc ! ** awk ! ** perl ! ** X ** Awk output is slightly different from that of the other shells in that X ** the actual variable settings are not printed but each line of an X ** associative array is printed (the first field is the array index, the *************** *** 178,254 **** X ** the Bourne shell ("sh") will be assumed. X ** X ** If the user wishes to use a value other than "TRUE" for a boolean ! ** flag that is true, this may be done using the "-T string" option. ! ** The same may also be done for a boolean flag that is false using the ! ** "-F string" option. X ** X ** Parseargs will only set the values of variables that correspond to ! ** arguments that were given on the command line. If a particular argu- ! ** ment was not supplied on the command line, then no assignment is made ! ** for the corresponding shell variable and it will have the same value ! ** that it had before parseargs was invoked. The only exception to this ! ** is that if the -u option is specified, then the positional parameters ! ** are unset before any shell variable assignments (which may reset the ! ** positional parameters) are made. X ***^^*********************************************************************/ X ! /* #defines for possible shell names and corresponding types */ ! typedef short shell_t; ! #define BASH ((shell_t) 0) ! #define TCSH ((shell_t) 1) ! #define CSH ((shell_t) 2) ! #define KSH ((shell_t) 3) ! #define SH ((shell_t) 4) ! #define RC ((shell_t) 5) ! #define AWK ((shell_t) 6) ! #define PERL ((shell_t) 7) ! ! #define BOURNE_AGAIN_SHELL "bash" ! #define BOURNE_SHELL "sh" ! #define KORN_SHELL "ksh" ! #define C_SHELL "csh" ! #define RC_SHELL "rc" ! #define TC_SHELL "tcsh" ! #define AWK_LANG "awk" ! #define PERL_LANG "perl" X X /* structure for shell-specific info */ X typedef struct { ! char *varname; /* name of variable containing the positional parameters */ ! char *setcmd; /* formatted string (%s is replaced with variable name) */ ! char *prefix; /* beginning for variable setting */ ! char *suffix; /* ending for variable setting */ X char *escape; /* format to escape chars (%c is the char to escape) */ X char *metachars; /* special characters that need to be escaped */ X } shell_info; X ! /* array of shell info - indexed by the #define for the shell type */ X static CONST shell_info Shell[] = { X ! /* BASH : Positional parms in -- ; Assignment Syntax: name="value"; */ ! { "--", "%s=", "'", "';\n", "'\\%c'", "'" }, X - /* TCSH : Positional parms in argv ; Assignment Syntax: set name="value"; */ - { "argv", "set %s=", "'", "';\n", "'\\%c'", "'" }, - - /* CSH : Positional parms in argv ; Assignment Syntax: set name="value"; */ SHAR_EOF true || echo 'restore of PATCH05 failed' fi echo 'End of part 2' echo 'File PATCH05 is continued in part 3' echo 3 > _shar_seq_.tmp exit 0 exit 0 # Just in case... -- Kent Landfield INTERNET: kent@sparky.IMD.Sterling.COM Sterling Software, IMD UUCP: uunet!sparky!kent Phone: (402) 291-8300 FAX: (402) 291-4362 Please send comp.sources.misc-related mail to kent@uunet.uu.net.