cvs.zerfleddert.de Git - micropolis/blame_incremental - src/tk/tkargv.c

/*
 * tkArgv.c --
 *
 *	This file contains a procedure that handles table-based
 *	argv-argc parsing.
 *
 * Copyright 1990 Regents of the University of California
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies.  The University of California
 * makes no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without
 * express or implied warranty.
 */

#ifndef lint
static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkArgv.c,v 1.12 92/08/07 08:39:48 ouster Exp $ SPRITE (Berkeley)";
#endif

#include "tkconfig.h"
#include "tk.h"

/*
 * Default table of argument descriptors.  These are normally available
 * in every application.
 */

static Tk_ArgvInfo defaultTable[] = {
    {"-help",	TK_ARGV_HELP,	(char *) NULL,	(char *) NULL,
	"Print summary of command-line options and abort"},
    {NULL,	TK_ARGV_END,	(char *) NULL,	(char *) NULL,
	(char *) NULL}
};

/*
 * Forward declarations for procedures defined in this file:
 */

static void	PrintUsage _ANSI_ARGS_((Tcl_Interp *interp,
		    Tk_ArgvInfo *argTable, int flags));
\f
/*
 *----------------------------------------------------------------------
 *
 * Tk_ParseArgv --
 *
 *	Process an argv array according to a table of expected
 *	command-line options.  See the manual page for more details.
 *
 * Results:
 *	The return value is a standard Tcl return value.  If an
 *	error occurs then an error message is left in interp->result.
 *	Under normal conditions, both *argcPtr and *argv are modified
 *	to return the arguments that couldn't be processed here (they
 *	didn't match the option table, or followed an TK_ARGV_REST
 *	argument).
 *
 * Side effects:
 *	Variables may be modified, resources may be entered for tkwin,
 *	or procedures may be called.  It all depends on the arguments
 *	and their entries in argTable.  See the user documentation
 *	for details.
 *
 *----------------------------------------------------------------------
 */

int
Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
    Tcl_Interp *interp;		/* Place to store error message. */
    Tk_Window tkwin;		/* Window to use for setting Tk options.
				 * NULL means ignore Tk option specs. */
    int *argcPtr;		/* Number of arguments in argv.  Modified
				 * to hold # args left in argv at end. */
    char **argv;		/* Array of arguments.  Modified to hold
				 * those that couldn't be processed here. */
    Tk_ArgvInfo *argTable;	/* Array of option descriptions */
    int flags;			/* Or'ed combination of various flag bits,
				 * such as TK_ARGV_NO_DEFAULTS. */
{
    register Tk_ArgvInfo *infoPtr;
				/* Pointer to the current entry in the
				 * table of argument descriptions. */
    Tk_ArgvInfo *matchPtr;	/* Descriptor that matches current argument. */
    char *curArg;		/* Current argument */
    register char c;		/* Second character of current arg (used for
				 * quick check for matching;  use 2nd char.
				 * because first char. will almost always
				 * be '-'). */
    int srcIndex;		/* Location from which to read next argument
				 * from argv. */
    int dstIndex;		/* Index into argv to which next unused
				 * argument should be copied (never greater
				 * than srcIndex). */
    int argc;			/* # arguments in argv still to process. */
    int length;			/* Number of characters in current argument. */
    int i;

    if (flags & TK_ARGV_DONT_SKIP_FIRST_ARG) {
	srcIndex = dstIndex = 0;
	argc = *argcPtr;
    } else {
	srcIndex = dstIndex = 1;
	argc = *argcPtr-1;
    }

    while (argc > 0) {
	curArg = argv[srcIndex];
	srcIndex++;
	argc--;
	c = curArg[1];
	length = strlen(curArg);

	/*
	 * Loop throught the argument descriptors searching for one with
	 * the matching key string.  If found, leave a pointer to it in
	 * matchPtr.
	 */

	matchPtr = NULL;
	for (i = 0; i < 2; i++) {
	    if (i == 0) {
		infoPtr = argTable;
	    } else {
		infoPtr = defaultTable;
	    }
	    for (; infoPtr->type != TK_ARGV_END; infoPtr++) {
		 if (infoPtr->key == NULL) {
		     continue;
		 }
		 if ((infoPtr->key[1] != c)
			 || (strncmp(infoPtr->key, curArg, length) != 0)) {
		     continue;
		 }
		 if ((tkwin == NULL)
			 && ((infoPtr->type == TK_ARGV_CONST_OPTION)
			 || (infoPtr->type == TK_ARGV_OPTION_VALUE)
			 || (infoPtr->type == TK_ARGV_OPTION_NAME_VALUE))) {
		     continue;
		 }
		 if (infoPtr->key[length] == 0) {
		     matchPtr = infoPtr;
		     goto gotMatch;
		 }
		 if (flags & TK_ARGV_NO_ABBREV) {
		     continue;
		 }
		 if (matchPtr != NULL) {
		     Tcl_AppendResult(interp, "ambiguous option \"", curArg,
			     "\"", (char *) NULL);
		     return TCL_ERROR;
		 }
		 matchPtr = infoPtr;
	    }
	}
	if (matchPtr == NULL) {

	    /*
	     * Unrecognized argument.  Just copy it down, unless the caller
	     * prefers an error to be registered.
	     */

	    if (flags & TK_ARGV_NO_LEFTOVERS) {
		Tcl_AppendResult(interp, "unrecognized argument \"",
			curArg, "\"", (char *) NULL);
		return TCL_ERROR;
	    }
	    argv[dstIndex] = curArg;
	    dstIndex++;
	    continue;
	}

	/*
	 * Take the appropriate action based on the option type
	 */

	gotMatch:
	infoPtr = matchPtr;
	switch (infoPtr->type) {
	    case TK_ARGV_CONSTANT:
		*((int *) infoPtr->dst) = (int) infoPtr->src;
		break;
	    case TK_ARGV_INT:
		if (argc == 0) {
		    goto missingArg;
		} else {
		    char *endPtr;

		    *((int *) infoPtr->dst) =
			    strtol(argv[srcIndex], &endPtr, 0);
		    if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
			Tcl_AppendResult(interp, "expected integer argument ",
				"for \"", infoPtr->key, "\" but got \"",
				argv[srcIndex], "\"", (char *) NULL);
			return TCL_ERROR;
		    }
		    srcIndex++;
		    argc--;
		}
		break;
	    case TK_ARGV_STRING:
		if (argc == 0) {
		    goto missingArg;
		} else {
		    *((char **)infoPtr->dst) = argv[srcIndex];
		    srcIndex++;
		    argc--;
		}
		break;
	    case TK_ARGV_UID:
		if (argc == 0) {
		    goto missingArg;
		} else {
		    *((Tk_Uid *)infoPtr->dst) = Tk_GetUid(argv[srcIndex]);
		    srcIndex++;
		    argc--;
		}
		break;
	    case TK_ARGV_REST:
		*((int *) infoPtr->dst) = dstIndex;
		goto argsDone;
	    case TK_ARGV_FLOAT:
		if (argc == 0) {
		    goto missingArg;
		} else {
		    char *endPtr;

		    *((double *) infoPtr->dst) =
			    strtod(argv[srcIndex], &endPtr);
		    if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
			Tcl_AppendResult(interp, "expected floating-point ",
				"argument for \"", infoPtr->key,
				"\" but got \"", argv[srcIndex], "\"",
				(char *) NULL);
			return TCL_ERROR;
		    }
		    srcIndex++;
		    argc--;
		}
		break;
	    case TK_ARGV_FUNC: {
		int (*handlerProc)();

		handlerProc = (int (*)())infoPtr->src;

		if ((*handlerProc)(infoPtr->dst, infoPtr->key,
			argv[srcIndex])) {
		    srcIndex += 1;
		    argc -= 1;
		}
		break;
	    }
	    case TK_ARGV_GENFUNC: {
		int	    (*handlerProc)();

		handlerProc = (int (*)())infoPtr->src;

		argc = (*handlerProc)(infoPtr->dst, interp, infoPtr->key,
			argc, argv+srcIndex);
		if (argc < 0) {
		    return TCL_ERROR;
		}
		break;
	    }
	    case TK_ARGV_HELP:
		PrintUsage (interp, argTable, flags);
		return TCL_ERROR;
	    case TK_ARGV_CONST_OPTION:
		Tk_AddOption(tkwin, infoPtr->dst, infoPtr->src,
			TK_INTERACTIVE_PRIO);
		break;
	    case TK_ARGV_OPTION_VALUE:
		if (argc < 1) {
		    goto missingArg;
		}
		Tk_AddOption(tkwin, infoPtr->dst, argv[srcIndex],
			TK_INTERACTIVE_PRIO);
		srcIndex++;
		argc--;
		break;
	    case TK_ARGV_OPTION_NAME_VALUE:
		if (argc < 2) {
		    Tcl_AppendResult(interp, "\"", curArg,
			    "\" option requires two following arguments",
			    (char *) NULL);
		    return TCL_ERROR;
		}
		Tk_AddOption(tkwin, argv[srcIndex], argv[srcIndex+1],
			TK_INTERACTIVE_PRIO);
		srcIndex += 2;
		argc -= 2;
		break;
	    default:
		sprintf(interp->result, "bad argument type %d in Tk_ArgvInfo",
			infoPtr->type);
		return TCL_ERROR;
	}
    }

    /*
     * If we broke out of the loop because of an OPT_REST argument,
     * copy the remaining arguments down.
     */

    argsDone:
    while (argc) {
	argv[dstIndex] = argv[srcIndex];
	srcIndex++;
	dstIndex++;
	argc--;
    }
    argv[dstIndex] = (char *) NULL;
    *argcPtr = dstIndex;
    return TCL_OK;

    missingArg:
    Tcl_AppendResult(interp, "\"", curArg,
	    "\" option requires an additional argument", (char *) NULL);
    return TCL_ERROR;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * PrintUsage --
 *
 *	Generate a help string describing command-line options.
 *
 * Results:
 *	Interp->result will be modified to hold a help string
 *	describing all the options in argTable, plus all those
 *	in the default table unless TK_ARGV_NO_DEFAULTS is
 *	specified in flags.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static void
PrintUsage(interp, argTable, flags)
    Tcl_Interp *interp;		/* Place information in this interp's
				 * result area. */
    Tk_ArgvInfo *argTable;	/* Array of command-specific argument
				 * descriptions. */
    int flags;			/* If the TK_ARGV_NO_DEFAULTS bit is set
				 * in this word, then don't generate
				 * information for default options. */
{
    register Tk_ArgvInfo *infoPtr;
    int width, i, numSpaces;
#define NUM_SPACES 20
    static char spaces[] = "                    ";
    char tmp[30];

    /*
     * First, compute the width of the widest option key, so that we
     * can make everything line up.
     */

    width = 4;
    for (i = 0; i < 2; i++) {
	for (infoPtr = i ? defaultTable : argTable;
		infoPtr->type != TK_ARGV_END; infoPtr++) {
	    int length;
	    if (infoPtr->key == NULL) {
		continue;
	    }
	    length = strlen(infoPtr->key);
	    if (length > width) {
		width = length;
	    }
	}
    }

    Tcl_AppendResult(interp, "Command-specific options:", (char *) NULL);
    for (i = 0; ; i++) {
	for (infoPtr = i ? defaultTable : argTable;
		infoPtr->type != TK_ARGV_END; infoPtr++) {
	    if ((infoPtr->type == TK_ARGV_HELP) && (infoPtr->key == NULL)) {
		Tcl_AppendResult(interp, "\n", infoPtr->help, (char *) NULL);
		continue;
	    }
	    Tcl_AppendResult(interp, "\n ", infoPtr->key, ":", (char *) NULL);
	    numSpaces = width + 1 - strlen(infoPtr->key);
	    while (numSpaces > 0) {
		if (numSpaces >= NUM_SPACES) {
		    Tcl_AppendResult(interp, spaces, (char *) NULL);
		} else {
		    Tcl_AppendResult(interp, spaces+NUM_SPACES-numSpaces,
			    (char *) NULL);
		}
		numSpaces -= NUM_SPACES;
	    }
	    Tcl_AppendResult(interp, infoPtr->help, (char *) NULL);
	    switch (infoPtr->type) {
		case TK_ARGV_INT: {
		    sprintf(tmp, "%d", *((int *) infoPtr->dst));
		    Tcl_AppendResult(interp, "\n\t\tDefault value: ",
			    tmp, (char *) NULL);
		    break;
		}
		case TK_ARGV_FLOAT: {
		    sprintf(tmp, "%lg", *((double *) infoPtr->dst));
		    Tcl_AppendResult(interp, "\n\t\tDefault value: ",
			    tmp, (char *) NULL);
		    break;
		}
		case TK_ARGV_STRING: {
		    char *string;

		    string = *((char **) infoPtr->dst);
		    if (string != NULL) {
			Tcl_AppendResult(interp, "\n\t\tDefault value: \"",
				string, "\"", (char *) NULL);
		    }
		    break;
		}
		default: {
		    break;
		}
	    }
	}

	if ((flags & TK_ARGV_NO_DEFAULTS) || (i > 0)) {
	    break;
	}
	Tcl_AppendResult(interp, "\nGeneric options for all commands:",
		(char *) NULL);
    }
}
Commit	Line	Data
	1	/*
	2	* tkArgv.c --
	3	*
	4	* This file contains a procedure that handles table-based
	5	* argv-argc parsing.
	6	*
	7	* Copyright 1990 Regents of the University of California
	8	* Permission to use, copy, modify, and distribute this
	9	* software and its documentation for any purpose and without
	10	* fee is hereby granted, provided that the above copyright
	11	* notice appear in all copies. The University of California
	12	* makes no representations about the suitability of this
	13	* software for any purpose. It is provided "as is" without
	14	* express or implied warranty.
	15	*/
	16
	17	#ifndef lint
	18	static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkArgv.c,v 1.12 92/08/07 08:39:48 ouster Exp $ SPRITE (Berkeley)";
	19	#endif
	20
	21	#include "tkconfig.h"
	22	#include "tk.h"
	23
	24	/*
	25	* Default table of argument descriptors. These are normally available
	26	* in every application.
	27	*/
	28
	29	static Tk_ArgvInfo defaultTable[] = {
	30	{"-help", TK_ARGV_HELP, (char ) NULL, (char ) NULL,
	31	"Print summary of command-line options and abort"},
	32	{NULL, TK_ARGV_END, (char ) NULL, (char ) NULL,
	33	(char *) NULL}
	34	};
	35
	36	/*
	37	* Forward declarations for procedures defined in this file:
	38	*/
	39
	40	static void PrintUsage _ANSI_ARGS_((Tcl_Interp *interp,
	41	Tk_ArgvInfo *argTable, int flags));
	42	\f
	43	/*
	44	*----------------------------------------------------------------------
	45	*
	46	* Tk_ParseArgv --
	47	*
	48	* Process an argv array according to a table of expected
	49	* command-line options. See the manual page for more details.
	50	*
	51	* Results:
	52	* The return value is a standard Tcl return value. If an
	53	* error occurs then an error message is left in interp->result.
	54	* Under normal conditions, both argcPtr and argv are modified
	55	* to return the arguments that couldn't be processed here (they
	56	* didn't match the option table, or followed an TK_ARGV_REST
	57	* argument).
	58	*
	59	* Side effects:
	60	* Variables may be modified, resources may be entered for tkwin,
	61	* or procedures may be called. It all depends on the arguments
	62	* and their entries in argTable. See the user documentation
	63	* for details.
	64	*
	65	*----------------------------------------------------------------------
	66	*/
	67
	68	int
	69	Tk_ParseArgv(interp, tkwin, argcPtr, argv, argTable, flags)
	70	Tcl_Interp interp; / Place to store error message. */
	71	Tk_Window tkwin; /* Window to use for setting Tk options.
	72	* NULL means ignore Tk option specs. */
	73	int argcPtr; / Number of arguments in argv. Modified
	74	* to hold # args left in argv at end. */
	75	char *argv; / Array of arguments. Modified to hold
	76	* those that couldn't be processed here. */
	77	Tk_ArgvInfo argTable; / Array of option descriptions */
	78	int flags; /* Or'ed combination of various flag bits,
	79	* such as TK_ARGV_NO_DEFAULTS. */
	80	{
	81	register Tk_ArgvInfo *infoPtr;
	82	/* Pointer to the current entry in the
	83	* table of argument descriptions. */
	84	Tk_ArgvInfo matchPtr; / Descriptor that matches current argument. */
	85	char curArg; / Current argument */
	86	register char c; /* Second character of current arg (used for
	87	* quick check for matching; use 2nd char.
	88	* because first char. will almost always
	89	* be '-'). */
	90	int srcIndex; /* Location from which to read next argument
	91	* from argv. */
	92	int dstIndex; /* Index into argv to which next unused
	93	* argument should be copied (never greater
	94	* than srcIndex). */
	95	int argc; /* # arguments in argv still to process. */
	96	int length; /* Number of characters in current argument. */
	97	int i;
	98
	99	if (flags & TK_ARGV_DONT_SKIP_FIRST_ARG) {
	100	srcIndex = dstIndex = 0;
	101	argc = *argcPtr;
	102	} else {
	103	srcIndex = dstIndex = 1;
	104	argc = *argcPtr-1;
	105	}
	106
	107	while (argc > 0) {
	108	curArg = argv[srcIndex];
	109	srcIndex++;
	110	argc--;
	111	c = curArg[1];
	112	length = strlen(curArg);
	113
	114	/*
	115	* Loop throught the argument descriptors searching for one with
	116	* the matching key string. If found, leave a pointer to it in
	117	* matchPtr.
	118	*/
	119
	120	matchPtr = NULL;
	121	for (i = 0; i < 2; i++) {
	122	if (i == 0) {
	123	infoPtr = argTable;
	124	} else {
	125	infoPtr = defaultTable;
	126	}
	127	for (; infoPtr->type != TK_ARGV_END; infoPtr++) {
	128	if (infoPtr->key == NULL) {
	129	continue;
	130	}
	131	if ((infoPtr->key[1] != c)
	132	\|\| (strncmp(infoPtr->key, curArg, length) != 0)) {
	133	continue;
	134	}
	135	if ((tkwin == NULL)
	136	&& ((infoPtr->type == TK_ARGV_CONST_OPTION)
	137	\|\| (infoPtr->type == TK_ARGV_OPTION_VALUE)
	138	\|\| (infoPtr->type == TK_ARGV_OPTION_NAME_VALUE))) {
	139	continue;
	140	}
	141	if (infoPtr->key[length] == 0) {
	142	matchPtr = infoPtr;
	143	goto gotMatch;
	144	}
	145	if (flags & TK_ARGV_NO_ABBREV) {
	146	continue;
	147	}
	148	if (matchPtr != NULL) {
	149	Tcl_AppendResult(interp, "ambiguous option \"", curArg,
	150	"\"", (char *) NULL);
	151	return TCL_ERROR;
	152	}
	153	matchPtr = infoPtr;
	154	}
	155	}
	156	if (matchPtr == NULL) {
	157
	158	/*
	159	* Unrecognized argument. Just copy it down, unless the caller
	160	* prefers an error to be registered.
	161	*/
	162
	163	if (flags & TK_ARGV_NO_LEFTOVERS) {
	164	Tcl_AppendResult(interp, "unrecognized argument \"",
	165	curArg, "\"", (char *) NULL);
	166	return TCL_ERROR;
	167	}
	168	argv[dstIndex] = curArg;
	169	dstIndex++;
	170	continue;
	171	}
	172
	173	/*
	174	* Take the appropriate action based on the option type
	175	*/
	176
	177	gotMatch:
	178	infoPtr = matchPtr;
	179	switch (infoPtr->type) {
	180	case TK_ARGV_CONSTANT:
	181	((int ) infoPtr->dst) = (int) infoPtr->src;
	182	break;
	183	case TK_ARGV_INT:
	184	if (argc == 0) {
	185	goto missingArg;
	186	} else {
	187	char *endPtr;
	188
	189	((int ) infoPtr->dst) =
	190	strtol(argv[srcIndex], &endPtr, 0);
	191	if ((endPtr == argv[srcIndex]) \|\| (*endPtr != 0)) {
	192	Tcl_AppendResult(interp, "expected integer argument ",
	193	"for \"", infoPtr->key, "\" but got \"",
	194	argv[srcIndex], "\"", (char *) NULL);
	195	return TCL_ERROR;
	196	}
	197	srcIndex++;
	198	argc--;
	199	}
	200	break;
	201	case TK_ARGV_STRING:
	202	if (argc == 0) {
	203	goto missingArg;
	204	} else {
	205	((char *)infoPtr->dst) = argv[srcIndex];
	206	srcIndex++;
	207	argc--;
	208	}
	209	break;
	210	case TK_ARGV_UID:
	211	if (argc == 0) {
	212	goto missingArg;
	213	} else {
	214	((Tk_Uid )infoPtr->dst) = Tk_GetUid(argv[srcIndex]);
	215	srcIndex++;
	216	argc--;
	217	}
	218	break;
	219	case TK_ARGV_REST:
	220	((int ) infoPtr->dst) = dstIndex;
	221	goto argsDone;
	222	case TK_ARGV_FLOAT:
	223	if (argc == 0) {
	224	goto missingArg;
	225	} else {
	226	char *endPtr;
	227
	228	((double ) infoPtr->dst) =
	229	strtod(argv[srcIndex], &endPtr);
	230	if ((endPtr == argv[srcIndex]) \|\| (*endPtr != 0)) {
	231	Tcl_AppendResult(interp, "expected floating-point ",
	232	"argument for \"", infoPtr->key,
	233	"\" but got \"", argv[srcIndex], "\"",
	234	(char *) NULL);
	235	return TCL_ERROR;
	236	}
	237	srcIndex++;
	238	argc--;
	239	}
	240	break;
	241	case TK_ARGV_FUNC: {
	242	int (*handlerProc)();
	243
	244	handlerProc = (int (*)())infoPtr->src;
	245
	246	if ((*handlerProc)(infoPtr->dst, infoPtr->key,
	247	argv[srcIndex])) {
	248	srcIndex += 1;
	249	argc -= 1;
	250	}
	251	break;
	252	}
	253	case TK_ARGV_GENFUNC: {
	254	int (*handlerProc)();
	255
	256	handlerProc = (int (*)())infoPtr->src;
	257
	258	argc = (*handlerProc)(infoPtr->dst, interp, infoPtr->key,
	259	argc, argv+srcIndex);
	260	if (argc < 0) {
	261	return TCL_ERROR;
	262	}
	263	break;
	264	}
	265	case TK_ARGV_HELP:
	266	PrintUsage (interp, argTable, flags);
	267	return TCL_ERROR;
	268	case TK_ARGV_CONST_OPTION:
	269	Tk_AddOption(tkwin, infoPtr->dst, infoPtr->src,
	270	TK_INTERACTIVE_PRIO);
	271	break;
	272	case TK_ARGV_OPTION_VALUE:
	273	if (argc < 1) {
	274	goto missingArg;
	275	}
	276	Tk_AddOption(tkwin, infoPtr->dst, argv[srcIndex],
	277	TK_INTERACTIVE_PRIO);
	278	srcIndex++;
	279	argc--;
	280	break;
	281	case TK_ARGV_OPTION_NAME_VALUE:
	282	if (argc < 2) {
	283	Tcl_AppendResult(interp, "\"", curArg,
	284	"\" option requires two following arguments",
	285	(char *) NULL);
	286	return TCL_ERROR;
	287	}
	288	Tk_AddOption(tkwin, argv[srcIndex], argv[srcIndex+1],
	289	TK_INTERACTIVE_PRIO);
	290	srcIndex += 2;
	291	argc -= 2;
	292	break;
	293	default:
	294	sprintf(interp->result, "bad argument type %d in Tk_ArgvInfo",
	295	infoPtr->type);
	296	return TCL_ERROR;
	297	}
	298	}
	299
	300	/*
	301	* If we broke out of the loop because of an OPT_REST argument,
	302	* copy the remaining arguments down.
	303	*/
	304
	305	argsDone:
	306	while (argc) {
	307	argv[dstIndex] = argv[srcIndex];
	308	srcIndex++;
	309	dstIndex++;
	310	argc--;
	311	}
	312	argv[dstIndex] = (char *) NULL;
	313	*argcPtr = dstIndex;
	314	return TCL_OK;
	315
	316	missingArg:
	317	Tcl_AppendResult(interp, "\"", curArg,
	318	"\" option requires an additional argument", (char *) NULL);
	319	return TCL_ERROR;
	320	}
	321	\f
	322	/*
	323	*----------------------------------------------------------------------
	324	*
	325	* PrintUsage --
	326	*
	327	* Generate a help string describing command-line options.
	328	*
	329	* Results:
	330	* Interp->result will be modified to hold a help string
	331	* describing all the options in argTable, plus all those
	332	* in the default table unless TK_ARGV_NO_DEFAULTS is
	333	* specified in flags.
	334	*
	335	* Side effects:
	336	* None.
	337	*
	338	*----------------------------------------------------------------------
	339	*/
	340
	341	static void
	342	PrintUsage(interp, argTable, flags)
	343	Tcl_Interp interp; / Place information in this interp's
	344	* result area. */
	345	Tk_ArgvInfo argTable; / Array of command-specific argument
	346	* descriptions. */
	347	int flags; /* If the TK_ARGV_NO_DEFAULTS bit is set
	348	* in this word, then don't generate
	349	* information for default options. */
	350	{
	351	register Tk_ArgvInfo *infoPtr;
	352	int width, i, numSpaces;
	353	#define NUM_SPACES 20
	354	static char spaces[] = " ";
	355	char tmp[30];
	356
	357	/*
	358	* First, compute the width of the widest option key, so that we
	359	* can make everything line up.
	360	*/
	361
	362	width = 4;
	363	for (i = 0; i < 2; i++) {
	364	for (infoPtr = i ? defaultTable : argTable;
	365	infoPtr->type != TK_ARGV_END; infoPtr++) {
	366	int length;
	367	if (infoPtr->key == NULL) {
	368	continue;
	369	}
	370	length = strlen(infoPtr->key);
	371	if (length > width) {
	372	width = length;
	373	}
	374	}
	375	}
	376
	377	Tcl_AppendResult(interp, "Command-specific options:", (char *) NULL);
	378	for (i = 0; ; i++) {
	379	for (infoPtr = i ? defaultTable : argTable;
	380	infoPtr->type != TK_ARGV_END; infoPtr++) {
	381	if ((infoPtr->type == TK_ARGV_HELP) && (infoPtr->key == NULL)) {
	382	Tcl_AppendResult(interp, "\n", infoPtr->help, (char *) NULL);
	383	continue;
	384	}
	385	Tcl_AppendResult(interp, "\n ", infoPtr->key, ":", (char *) NULL);
	386	numSpaces = width + 1 - strlen(infoPtr->key);
	387	while (numSpaces > 0) {
	388	if (numSpaces >= NUM_SPACES) {
	389	Tcl_AppendResult(interp, spaces, (char *) NULL);
	390	} else {
	391	Tcl_AppendResult(interp, spaces+NUM_SPACES-numSpaces,
	392	(char *) NULL);
	393	}
	394	numSpaces -= NUM_SPACES;
	395	}
	396	Tcl_AppendResult(interp, infoPtr->help, (char *) NULL);
	397	switch (infoPtr->type) {
	398	case TK_ARGV_INT: {
	399	sprintf(tmp, "%d", ((int ) infoPtr->dst));
	400	Tcl_AppendResult(interp, "\n\t\tDefault value: ",
	401	tmp, (char *) NULL);
	402	break;
	403	}
	404	case TK_ARGV_FLOAT: {
	405	sprintf(tmp, "%lg", ((double ) infoPtr->dst));
	406	Tcl_AppendResult(interp, "\n\t\tDefault value: ",
	407	tmp, (char *) NULL);
	408	break;
	409	}
	410	case TK_ARGV_STRING: {
	411	char *string;
	412
	413	string = ((char *) infoPtr->dst);
	414	if (string != NULL) {
	415	Tcl_AppendResult(interp, "\n\t\tDefault value: \"",
	416	string, "\"", (char *) NULL);
	417	}
	418	break;
	419	}
	420	default: {
	421	break;
	422	}
	423	}
	424	}
	425
	426	if ((flags & TK_ARGV_NO_DEFAULTS) \|\| (i > 0)) {
	427	break;
	428	}
	429	Tcl_AppendResult(interp, "\nGeneric options for all commands:",
	430	(char *) NULL);
	431	}
	432	}