![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkargv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkargv.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 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:
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:
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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.