![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckucmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / kermit|
Return to ckucmd.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / kermit |
1.1 root 1: char *cmdv = "Unix cmd package V1A(021), 19 Jun 85";
2:
3: /* C K U C M D -- Interactive command package for Unix */
4: /*
5: Modelled after the DECSYSTEM-20 command parser (the COMND JSYS)
6:
7: Features:
8: . parses and verifies keywords, text strings, numbers, and other data
9: . displays appropriate menu or help message when user types "?"
10: . does keyword and filename completion when user types ESC
11: . accepts any unique abbreviation for a keyword
12: . allows keywords to have attributes, like "invisible"
13: . can supply defaults for fields omitted by user
14: . provides command line editing (character, word, and line deletion)
15: . accepts input from keyboard, command files, or redirected stdin
16: . allows for full or half duplex operation, character or line input
17: . settable prompt, protected from deletion
18:
19: Functions:
20: cmsetp - Set prompt (cmprom is prompt string, cmerrp is error msg prefix)
21: cmsavp - Save current prompt
22: prompt - Issue prompt
23: cmini - Clear the command buffer (before parsing a new command)
24: cmres - Reset command buffer pointers (before reparsing)
25: cmkey - Parse a keyword
26: cmnum - Parse a number
27: cmifi - Parse an input file name
28: cmofi - Parse an output file name
29: cmfld - Parse an arbitrary field
30: cmtxt - Parse a text string
31: cmcfm - Parse command confirmation (end of line)
32: stripq - Strip out backslash quotes from a string.
33:
34: Return codes:
35: -3: no input provided when required
36: -2: input was invalid
37: -1: reparse required (user deleted into a preceding field)
38: 0 or greater: success
39: See individual functions for greater detail.
40:
41: Before using these routines, the caller should #include ckucmd.h, and
42: set the program's prompt by calling cmsetp(). If the file parsing
43: functions cmifi and cmofi are to be used, this module must be linked
44: with a ck?fio file system support module for the appropriate system,
45: e.g. ckufio for Unix. If the caller puts the terminal in
46: character wakeup ("cbreak") mode with no echo, then these functions will
47: provide line editing -- character, word, and line deletion, as well as
48: keyword and filename completion upon ESC and help strings, keyword, or
49: file menus upon '?'. If the caller puts the terminal into character
50: wakeup/noecho mode, care should be taken to restore it before exit from
51: or interruption of the program. If the character wakeup mode is not
52: set, the system's own line editor may be used.
53:
54: Author: Frank da Cruz (SY.FDC@CU20B),
55: Columbia University Center for Computing Activities, January 1985.
56: Copyright (C) 1985, Trustees of Columbia University in the City of New York.
57: Permission is granted to any individual or institution to use, copy, or
58: redistribute this software so long as it is not sold for profit, provided this
59: copyright notice is retained.
60: */
61:
62: /* Includes */
63:
64: #include <stdio.h> /* Standard C I/O package */
65: #include <ctype.h> /* Character types */
66: #include "ckucmd.h" /* Command parsing definitions */
67: #include "ckcdeb.h" /* Formats for debug() */
68:
69: /* Local variables */
70:
71: int psetf = 0, /* Flag that prompt has been set */
72: cc = 0, /* Character count */
73: dpx = 0; /* Duplex (0 = full) */
74:
75: int hw = HLPLW, /* Help line width */
76: hc = HLPCW, /* Help line column width */
77: hh, /* Current help column number */
78: hx; /* Current help line position */
79:
80: #define PROML 60 /* Maximum length for prompt */
81:
82: char cmprom[PROML+1]; /* Program's prompt */
83: char *dfprom = "Command? "; /* Default prompt */
84:
85: char cmerrp[PROML+1]; /* Program's error message prefix */
86:
87: int cmflgs; /* Command flags */
88:
89: char cmdbuf[CMDBL+4]; /* Command buffer */
90: char hlpbuf[HLPBL+4]; /* Help string buffer */
91: char atmbuf[ATMBL+4]; /* Atom buffer */
92: char filbuf[ATMBL+4]; /* File name buffer */
93:
94: /* Command buffer pointers */
95:
96: static char *bp, /* Current command buffer position */
97: *pp, /* Start of current field */
98: *np; /* Start of next field */
99:
100: long zchki(); /* From ck?fio.c. */
101:
102:
103: /* C M S E T P -- Set the program prompt. */
104:
105: cmsetp(s) char *s; {
106: char *sx, *sy, *strncpy();
107: psetf = 1; /* Flag that prompt has been set. */
108: strncpy(cmprom,s,PROML - 1); /* Copy the string. */
109: cmprom[PROML] = NUL; /* Ensure null terminator. */
110: sx = cmprom; sy = cmerrp; /* Also use as error message prefix. */
111: while (*sy++ = *sx++) ; /* Copy. */
112: sy -= 2; if (*sy == '>') *sy = NUL; /* Delete any final '>'. */
113: }
114: /* C M S A V P -- Save a copy of the current prompt. */
115:
116: cmsavp(s,n) int n; char s[]; {
117: extern char *strncpy(); /* +1 */
118: strncpy(s,cmprom,n-1);
119: s[n] = NUL;
120: }
121:
122: /* P R O M P T -- Issue the program prompt. */
123:
124: prompt() {
125: if (psetf == 0) cmsetp(dfprom); /* If no prompt set, set default. */
126: printf("\r%s",cmprom); /* Print the prompt. */
127: }
128:
129:
130: /* C M R E S -- Reset pointers to beginning of command buffer. */
131:
132: cmres() {
133: cc = 0; /* Reset character counter. */
134: pp = np = bp = cmdbuf; /* Point to command buffer. */
135: cmflgs = -5; /* Parse not yet started. */
136: }
137:
138:
139: /* C M I N I -- Clear the command and atom buffers, reset pointers. */
140:
141: /*
142: The argument specifies who is to echo the user's typein --
143: 1 means the cmd package echoes
144: 0 somebody else (system, front end, terminal) echoes
145: */
146: cmini(d) int d; {
147: for (bp = cmdbuf; bp < cmdbuf+CMDBL; bp++) *bp = NUL;
148: *atmbuf = NUL;
149: dpx = d;
150: cmres();
151: }
152:
153: stripq(s) char *s; { /* Function to strip '\' quotes */
154: char *t;
155: while (*s) {
156: if (*s == '\\') {
157: for (t = s; *t != '\0'; t++) *t = *(t+1);
158: }
159: s++;
160: }
161: }
162:
163:
164: /* C M N U M -- Parse a number in the indicated radix */
165:
166: /* For now, only works for positive numbers in base 10. */
167:
168: /*
169: Returns
170: -3 if no input present when required,
171: -2 if user typed an illegal number,
172: -1 if reparse needed,
173: 0 otherwise, with n set to number that was parsed
174: */
175: cmnum(xhlp,xdef,radix,n) char *xhlp, *xdef; int radix, *n; {
176: int x; char *s;
177:
178: if (radix != 10) { /* Just do base 10 for now */
179: printf("cmnum: illegal radix - %d\n",radix);
180: return(-1);
181: }
182:
183: x = cmfld(xhlp,xdef,&s);
184: debug(F101,"cmnum: cmfld","",x);
185: if (x < 0) return(x); /* Parse a field */
186:
187: if (digits(atmbuf)) { /* Convert to number */
188: *n = atoi(atmbuf);
189: return(x);
190: } else {
191: printf("\n?not a number - %s\n",s);
192: return(-2);
193: }
194: }
195:
196:
197: /* C M O F I -- Parse the name of an output file */
198:
199: /*
200: Depends on the external function zchko(); if zchko() not available, use
201: cmfld() to parse output file names.
202:
203: Returns
204: -3 if no input present when required,
205: -2 if permission would be denied to create the file,
206: -1 if reparse needed,
207: 0 or 1 otherwise, with xp pointing to name.
208: */
209: cmofi(xhlp,xdef,xp) char *xhlp, *xdef, **xp; {
210: int x; char *s;
211:
212: if (*xhlp == NUL) xhlp = "Output file";
213: *xp = "";
214:
215: if ((x = cmfld(xhlp,xdef,&s)) < 0) return(x);
216:
217: if (chkwld(s)) {
218: printf("\n?Wildcards not allowed - %s\n",s);
219: return(-2);
220: }
221: if (zchko(s) < 0) {
222: printf("\n?Write permission denied - %s\n",s);
223: return(-2);
224: } else {
225: *xp = s;
226: return(x);
227: }
228: }
229:
230:
231: /* C M I F I -- Parse the name of an existing file */
232:
233: /*
234: This function depends on the external functions:
235: zchki() - Check if input file exists and is readable.
236: zxpand() - Expand a wild file specification into a list.
237: znext() - Return next file name from list.
238: If these functions aren't available, then use cmfld() to parse filenames.
239: */
240: /*
241: Returns
242: -4 EOF
243: -3 if no input present when required,
244: -2 if file does not exist or is not readable,
245: -1 if reparse needed,
246: 0 or 1 otherwise, with:
247: xp pointing to name,
248: wild = 1 if name contains '*' or '?', 0 otherwise.
249: */
250: cmifi(xhlp,xdef,xp,wild) char *xhlp, *xdef, **xp; int *wild; {
251: int i, x, xc; long y; char *sp;
252:
253: cc = xc = 0; /* Initialize counts & pointers */
254: *xp = "";
255: if ((x = cmflgs) != 1) { /* Already confirmed? */
256: x = getwd(); /* No, get a word */
257: } else {
258: cc = setatm(xdef); /* If so, use default, if any. */
259: }
260: *xp = atmbuf; /* Point to result. */
261: *wild = chkwld(*xp);
262:
263: while (1) {
264: xc += cc; /* Count the characters. */
265: debug(F111,"cmifi: getwd",atmbuf,xc);
266: switch (x) {
267: case -4: /* EOF */
268: case -2: /* Out of space. */
269: case -1: /* Reparse needed */
270: return(x);
271:
272: /* cont'd... */
273:
274:
275: /* ...cmifi(), cont'd */
276:
277:
278: case 0: /* SP or NL */
279: case 1:
280: if (xc == 0) *xp = xdef; /* If no input, return default. */
281: else *xp = atmbuf;
282: if (**xp == NUL) return(-3); /* If field empty, return -3. */
283:
284: /* If filespec is wild, see if there are any matches */
285:
286: *wild = chkwld(*xp);
287: debug(F101," *wild","",*wild);
288: if (*wild != 0) {
289: y = zxpand(*xp);
290: if (y == 0) {
291: printf("\n?No files match - %s\n",*xp);
292: return(-2);
293: } else if (y < 0) {
294: printf("\n?Too many files match - %s\n",*xp);
295: return(-2);
296: } else return(x);
297: }
298:
299: /* If not wild, see if it exists and is readable. */
300:
301: y = zchki(*xp);
302: if (y == -3) {
303: printf("\n?Read permission denied - %s\n",*xp);
304: return(-2);
305: } else if (y == -2) {
306: printf("\n?File not readable - %s\n",*xp);
307: return(-2);
308: } else if (y < 0) {
309: printf("\n?File not found - %s\n",*xp);
310: return(-2);
311: }
312: return(x);
313: /* cont'd... */
314:
315:
316: /* ...cmifi(), cont'd */
317:
318:
319: case 2: /* ESC */
320: if (xc == 0) {
321: if (*xdef != '\0') {
322: printf("%s ",xdef); /* If at beginning of field, */
323: addbuf(xdef); /* supply default. */
324: cc = setatm(xdef);
325: } else { /* No default */
326: putchar(BEL);
327: }
328: break;
329: }
330: if (*wild = chkwld(*xp)) { /* No completion if wild */
331: putchar(BEL);
332: break;
333: }
334: sp = atmbuf + cc;
335: *sp++ = '*';
336: *sp-- = '\0';
337: y = zxpand(atmbuf); /* Add * and expand list. */
338: *sp = '\0'; /* Remove *. */
339:
340: if (y == 0) {
341: printf("\n?No files match - %s\n",atmbuf);
342: return(-2);
343: } else if (y < 0) {
344: printf("\n?Too many files match - %s\n",atmbuf);
345: return(-2);
346: } else if (y > 1) { /* Not unique, just beep. */
347: putchar(BEL);
348: } else { /* Unique, complete it. */
349: znext(filbuf); /* Get whole name of file. */
350: sp = filbuf + cc; /* Point past what user typed. */
351: printf("%s ",sp); /* Complete the name. */
352: addbuf(sp); /* Add the characters to cmdbuf. */
353: setatm(pp); /* And to atmbuf. */
354: *xp = atmbuf; /* Return pointer to atmbuf. */
355: return(cmflgs = 0);
356: }
357: break;
358:
359: /* cont'd... */
360:
361:
362: /* ...cmifi(), cont'd */
363:
364:
365: case 3: /* Question mark */
366: if (*xhlp == NUL)
367: printf(" Input file specification");
368: else
369: printf(" %s",xhlp);
370: if (xc > 0) {
371: sp = atmbuf + cc; /* Insert * at end */
372: *sp++ = '*';
373: *sp-- = '\0';
374: y = zxpand(atmbuf);
375: *sp = '\0';
376: if (y == 0) {
377: printf("\n?No files match - %s\n",atmbuf);
378: return(-2);
379: } else if (y < 0) {
380: printf("\n?Too many file match - %s\n",atmbuf);
381: return(-2);
382: } else {
383: printf(", one of the following:\n");
384: clrhlp();
385: for (i = 0; i < y; i++) {
386: znext(filbuf);
387: addhlp(filbuf);
388: }
389: dmphlp();
390: }
391: } else printf("\n");
392: printf("%s%s",cmprom,cmdbuf);
393: break;
394: }
395: x = getwd();
396: }
397: }
398:
399:
400:
401: /* C H K W L D -- Check for wildcard characters '*' or '?' */
402:
403: chkwld(s) char *s; {
404:
405: for ( ; *s != '\0'; s++) {
406: if ((*s == '*') || (*s == '?'))
407: return(1);
408: }
409: return(0);
410: }
411:
412:
413: /* C M F L D -- Parse an arbitrary field */
414: /*
415: Returns
416: -3 if no input present when required,
417: -2 if field too big for buffer,
418: -1 if reparse needed,
419: 0 otherwise, xp pointing to string result.
420: */
421: cmfld(xhlp,xdef,xp) char *xhlp, *xdef, **xp; {
422: int x, xc;
423:
424: cc = xc = 0; /* Initialize counts & pointers */
425: *xp = "";
426: if ((x = cmflgs) != 1) { /* Already confirmed? */
427: x = getwd(); /* No, get a word */
428: } else {
429: cc = setatm(xdef); /* If so, use default, if any. */
430: }
431: *xp = atmbuf; /* Point to result. */
432:
433: while (1) {
434: xc += cc; /* Count the characters. */
435: debug(F111,"cmfld: getwd",atmbuf,xc);
436: debug(F101," x","",x);
437: switch (x) {
438: case -4: /* EOF */
439: case -2: /* Out of space. */
440: case -1: /* Reparse needed */
441: return(x);
442: case 0: /* SP or NL */
443: case 1:
444: if (xc == 0) *xp = xdef; /* If no input, return default. */
445: else *xp = atmbuf;
446: if (**xp == NUL) x = -3; /* If field empty, return -3. */
447: return(x);
448: case 2: /* ESC */
449: if (xc == 0) {
450: printf("%s ",xdef); /* If at beginning of field, */
451: addbuf(xdef); /* supply default. */
452: cc = setatm(xdef); /* Return as if whole field */
453: return(0); /* typed, followed by space. */
454: } else {
455: putchar(BEL); /* Beep if already into field. */
456: }
457: break;
458: case 3: /* Question mark */
459: if (*xhlp == NUL)
460: printf(" Please complete this field");
461: else
462: printf(" %s",xhlp);
463: printf("\n%s%s",cmprom,cmdbuf);
464: break;
465: }
466: x = getwd();
467: }
468: }
469:
470:
471: /* C M T X T -- Get a text string, including confirmation */
472:
473: /*
474: Print help message 'xhlp' if ? typed, supply default 'xdef' if null
475: string typed. Returns
476:
477: -1 if reparse needed or buffer overflows.
478: 1 otherwise.
479:
480: with cmflgs set to return code, and xp pointing to result string.
481: */
482:
483: cmtxt(xhlp,xdef,xp) char *xhlp; char *xdef; char **xp; {
484:
485: int x;
486: static int xc;
487:
488: debug(F101,"cmtxt, cmflgs","",cmflgs);
489: cc = 0; /* Start atmbuf counter off at 0 */
490: if (cmflgs == -1) { /* If reparsing, */
491: xc = strlen(*xp); /* get back the total text length, */
492: } else { /* otherwise, */
493: *xp = ""; /* start fresh. */
494: xc = 0;
495: }
496: *atmbuf = NUL; /* And empty atom buffer. */
497: if ((x = cmflgs) != 1) {
498: x = getwd(); /* Get first word. */
499: *xp = pp; /* Save pointer to it. */
500: }
501: while (1) {
502: xc += cc; /* Char count for all words. */
503: debug(F111,"cmtxt: getwd",atmbuf,xc);
504: debug(F101," x","",x);
505: switch (x) {
506: case -4: /* EOF */
507: case -2: /* Overflow */
508: case -1: /* Deletion */
509: return(x);
510: case 0: /* Space */
511: xc++; /* Just count it */
512: break;
513: case 1: /* CR or LF */
514: if (xc == 0) *xp = xdef;
515: return(x);
516: case 2: /* ESC */
517: if (xc == 0) {
518: printf("%s ",xdef);
519: cc = addbuf(xdef);
520: } else {
521: putchar(BEL);
522: }
523: break;
524: case 3: /* Question Mark */
525: if (*xhlp == NUL)
526: printf(" Text string");
527: else
528: printf(" %s",xhlp);
529: printf("\n%s%s",cmprom,cmdbuf);
530: break;
531: default:
532: printf("\n?Unexpected return code from getwd() - %d\n",x);
533: return(-2);
534: }
535: x = getwd();
536: }
537: }
538:
539:
540: /* C M K E Y -- Parse a keyword */
541:
542: /*
543: Call with:
544: table -- keyword table, in 'struct keytab' format;
545: n -- number of entries in table;
546: xhlp -- pointer to help string;
547: xdef -- pointer to default keyword;
548:
549: Returns:
550: -3 -- no input supplied and no default available
551: -2 -- input doesn't uniquely match a keyword in the table
552: -1 -- user deleted too much, command reparse required
553: n >= 0 -- value associated with keyword
554: */
555:
556: cmkey(table,n,xhlp,xdef) struct keytab table[]; int n; char *xhlp, *xdef; {
557: int i, y, z, zz, xc;
558: char *xp;
559:
560: xc = cc = 0; /* Clear character counters. */
561:
562: if ((zz = cmflgs) == 1) /* Command already entered? */
563: setatm(xdef);
564: else zz = getwd();
565:
566: debug(F101,"cmkey: table length","",n);
567: debug(F101," cmflgs","",cmflgs);
568: debug(F101," zz","",zz);
569: while (1) {
570: xc += cc;
571: debug(F111,"cmkey: getwd",atmbuf,xc);
572:
573: switch(zz) {
574: case -4: /* EOF */
575: case -2: /* Buffer overflow */
576: case -1: /* Or user did some deleting. */
577: return(zz);
578:
579: case 0: /* User terminated word with space */
580: case 1: /* or newline */
581: if (cc == 0) setatm(xdef);
582: y = lookup(table,atmbuf,n,&z);
583: switch (y) {
584: case -2:
585: printf("\n?Ambiguous - %s\n",atmbuf);
586: return(cmflgs = -2);
587: case -1:
588: printf("\n?Invalid - %s\n",atmbuf);
589: return(cmflgs = -2);
590: default:
591: break;
592: }
593: return(y);
594:
595: /* cont'd... */
596:
597:
598: /* ...cmkey(), cont'd */
599:
600: case 2: /* User terminated word with ESC */
601: if (cc == 0) {
602: if (*xdef != NUL) { /* Nothing in atmbuf */
603: printf("%s ",xdef); /* Supply default if any */
604: addbuf(xdef);
605: cc = setatm(xdef);
606: debug(F111,"cmkey: default",atmbuf,cc);
607: } else {
608: putchar(BEL); /* No default, just beep */
609: break;
610: }
611: }
612: y = lookup(table,atmbuf,n,&z); /* Something in atmbuf */
613: debug(F111,"cmkey: esc",atmbuf,y);
614: if (y == -2) {
615: putchar(BEL);
616: break;
617: }
618: if (y == -1) {
619: printf("\n?Invalid - %s\n",atmbuf);
620: return(cmflgs = -2);
621: }
622: xp = table[z].kwd + cc;
623: printf("%s ",xp);
624: addbuf(xp);
625: debug(F110,"cmkey: addbuf",cmdbuf,0);
626: return(y);
627:
628: /* cont'd... */
629:
630:
631: /* ...cmkey(), cont'd */
632:
633: case 3: /* User terminated word with "?" */
634: y = lookup(table,atmbuf,n,&z);
635: if (y > -1) {
636: printf(" %s\n%s%s",table[z].kwd,cmprom,cmdbuf);
637: break;
638: } else if (y == -1) {
639: printf("\n?Invalid\n");
640: return(cmflgs = -2);
641: }
642:
643: if (*xhlp == NUL)
644: printf(" One of the following:\n");
645: else
646: printf(" %s, one of the following:\n",xhlp);
647:
648: clrhlp();
649: for (i = 0; i < n; i++) {
650: if (!strncmp(table[i].kwd,atmbuf,cc)
651: && !test(table[i].flgs,CM_INV))
652: addhlp(table[i].kwd);
653: }
654: dmphlp();
655: printf("%s%s", cmprom, cmdbuf);
656: break;
657:
658: default:
659: printf("\n%d - Unexpected return code from getwd\n",zz);
660: return(cmflgs = -2);
661: }
662: zz = getwd();
663: }
664: }
665:
666:
667: /* C M C F M -- Parse command confirmation (end of line) */
668:
669: /*
670: Returns
671: -2: User typed anything but whitespace or newline
672: -1: Reparse needed
673: 0: Confirmation was received
674: */
675:
676: cmcfm() {
677: int x, xc;
678:
679: debug(F101,"cmcfm: cmflgs","",cmflgs);
680:
681: xc = cc = 0;
682: if (cmflgs == 1) return(0);
683:
684: while (1) {
685: x = getwd();
686: xc += cc;
687: debug(F111,"cmcfm: getwd",atmbuf,xc);
688: switch (x) {
689: case -4: /* EOF */
690: case -2:
691: case -1:
692: return(x);
693:
694: case 0: /* Space */
695: continue;
696: case 1: /* End of line */
697: if (xc > 0) {
698: printf("?Not confirmed - %s\n",atmbuf);
699: return(-2);
700: } else return(0);
701: case 2:
702: putchar(BEL);
703: continue;
704:
705: case 3:
706: if (xc > 0) {
707: printf("\n?Not confirmed - %s\n",atmbuf);
708: return(-2);
709: }
710: printf("\n Type a carriage return to confirm the command\n");
711: printf("%s%s",cmprom,cmdbuf);
712: continue;
713: }
714: }
715: }
716:
717:
718: /* Keyword help routines */
719:
720:
721: /* C L R H L P -- Initialize/Clear the help line buffer */
722:
723: clrhlp() { /* Clear the help buffer */
724: hlpbuf[0] = NUL;
725: hh = hx = 0;
726: }
727:
728:
729: /* A D D H L P -- Add a string to the help line buffer */
730:
731: addhlp(s) char *s; { /* Add a word to the help buffer */
732: int j;
733:
734: hh++; /* Count this column */
735:
736: for (j = 0; (j < hc) && (*s != NUL); j++) { /* Fill the column */
737: hlpbuf[hx++] = *s++;
738: }
739: if (*s != NUL) /* Still some chars left in string? */
740: hlpbuf[hx-1] = '+'; /* Mark as too long for column. */
741:
742: if (hh < (hw / hc)) { /* Pad col with spaces if necessary */
743: for (; j < hc; j++) {
744: hlpbuf[hx++] = SP;
745: }
746: } else { /* If last column, */
747: hlpbuf[hx++] = NUL; /* no spaces. */
748: dmphlp(); /* Print it. */
749: return;
750: }
751: }
752:
753:
754: /* D M P H L P -- Dump the help line buffer */
755:
756: dmphlp() { /* Print the help buffer */
757: hlpbuf[hx++] = NUL;
758: printf(" %s\n",hlpbuf);
759: clrhlp();
760: }
761:
762:
763: /* L O O K U P -- Lookup the string in the given array of strings */
764:
765: /*
766: Call this way: v = lookup(table,word,n,&x);
767:
768: table - a 'struct keytab' table.
769: word - the target string to look up in the table.
770: n - the number of elements in the table.
771: x - address of an integer for returning the table array index.
772:
773: The keyword table must be arranged in ascending alphabetical order, and
774: all letters must be lowercase.
775:
776: Returns the keyword's associated value ( zero or greater ) if found,
777: with the variable x set to the array index, or:
778:
779: -3 if nothing to look up (target was null),
780: -2 if ambiguous,
781: -1 if not found.
782:
783: A match is successful if the target matches a keyword exactly, or if
784: the target is a prefix of exactly one keyword. It is ambiguous if the
785: target matches two or more keywords from the table.
786: */
787:
788: lookup(table,cmd,n,x) char *cmd; struct keytab table[]; int n, *x; {
789:
790: int i, v, cmdlen;
791:
792: /* Lowercase & get length of target, if it's null return code -3. */
793:
794: if ((((cmdlen = lower(cmd))) == 0) || (n < 1)) return(-3);
795:
796: /* Not null, look it up */
797:
798: for (i = 0; i < n-1; i++) {
799: if (!strcmp(table[i].kwd,cmd) ||
800: ((v = !strncmp(table[i].kwd,cmd,cmdlen)) &&
801: strncmp(table[i+1].kwd,cmd,cmdlen))) {
802: *x = i;
803: return(table[i].val);
804: }
805: if (v) return(-2);
806: }
807:
808: /* Last (or only) element */
809:
810: if (!strncmp(table[n-1].kwd,cmd,cmdlen)) {
811: *x = n-1;
812: return(table[n-1].val);
813: } else return(-1);
814: }
815:
816:
817: /* G E T W D -- Gets a "word" from the command input stream */
818:
819: /*
820: Usage: retcode = getwd();
821:
822: Returns:
823: -4 if end of file (e.g. pipe broken)
824: -2 if command buffer overflows
825: -1 if user did some deleting
826: 0 if word terminates with SP or tab
827: 1 if ... CR
828: 2 if ... ESC
829: 3 if ... ?
830:
831: With:
832: pp pointing to beginning of word in buffer
833: bp pointing to after current position
834: atmbuf containing a copy of the word
835: cc containing the number of characters in the word copied to atmbuf
836: */
837: getwd() {
838:
839: int c; /* Current char */
840: static int inword = 0; /* Flag for start of word found */
841: int quote = 0; /* Flag for quote character */
842: int echof = 0; /* Flag for whether to echo */
843: int ignore = 0;
844:
845: pp = np; /* Start of current field */
846: debug(F101,"getwd: cmdbuf","",(int) cmdbuf);
847: debug(F101," bp","",(int) bp);
848: debug(F101," pp","",(int) pp);
849: debug(F110," cmdbuf",cmdbuf,0);
850:
851: while (bp < cmdbuf+CMDBL) { /* Loop */
852:
853: ignore = echof = 0; /* Flag for whether to echo */
854:
855: if ((c = *bp) == NUL) { /* Get next character */
856: if (dpx) echof = 1; /* from reparse buffer */
857: c = getchar(); /* or from tty. */
858: if (c == EOF) return(-4);
859: } else ignore = 1;
860:
861: if (quote == 0) {
862:
863: if (!ignore && (c == '\\')) { /* Quote character */
864: quote = 1;
865: continue;
866: }
867: if (c == FF) { /* Formfeed. */
868: c = NL; /* Replace with newline */
869: system("clear"); /* and clear the screen. */
870: }
871:
872: if (c == HT) c = SP; /* Substitute space for tab. */
873:
874: /* cont'd... */
875:
876:
877: /* ...getwd(), cont'd */
878:
879: if (c == SP) { /* If space */
880: *bp++ = c; /* deposit it in buffer. */
881: if (echof) putchar(c); /* echo it. */
882: if (inword == 0) { /* If leading, gobble it. */
883: pp++;
884: continue;
885: } else { /* If terminating, return. */
886: np = bp;
887: setatm(pp);
888: inword = 0;
889: return(cmflgs = 0);
890: }
891: }
892: if (c == NL || c == CR) { /* CR, LF */
893: *bp = NUL; /* End the string */
894: if (echof) { /* If echoing, */
895: putchar(c); /* echo the typein */
896: #ifdef aegis
897: if (c == CR) putchar(NL);
898: #endif
899: }
900: np = bp; /* Where to start next field. */
901: setatm(pp); /* Copy this field to atom buffer. */
902: inword = 0;
903: return(cmflgs = 1);
904: }
905: if (!ignore && (c == '?')) { /* Question mark */
906: putchar(c);
907: *bp = NUL;
908: setatm(pp);
909: return(cmflgs = 3);
910: }
911: if (c == ESC) { /* ESC */
912: *bp = NUL;
913: setatm(pp);
914: return(cmflgs = 2);
915: }
916: if (c == BS || c == RUB) { /* Character deletion */
917: if (bp > cmdbuf) { /* If still in buffer... */
918: printf("\b \b"); /* erase character from screen, */
919: bp--; /* point behind it, */
920: if (*bp == SP) inword = 0; /* Flag if current field gone */
921: *bp = NUL; /* Erase character from buffer. */
922: } else { /* Otherwise, */
923: putchar(BEL); /* beep, */
924: cmres(); /* and start parsing a new command. */
925: }
926: if (pp < bp) continue;
927: else return(cmflgs = -1);
928: }
929: if (c == LDEL) { /* ^U, line deletion */
930: while ((bp--) > cmdbuf) {
931: printf("\b \b");
932: *bp = NUL;
933: }
934: cmres(); /* Restart the command. */
935: inword = 0;
936: return(cmflgs = -1);
937: }
938:
939: /* cont'd... */
940:
941:
942: /* ...getwd(), cont'd */
943:
944: if (c == WDEL) { /* ^W, word deletion */
945: if (bp <= cmdbuf) { /* Beep if nothing to delete */
946: putchar(BEL);
947: cmres();
948: return(cmflgs = -1);
949: }
950: bp--;
951: for ( ; (bp >= cmdbuf) && (*bp == SP) ; bp--) {
952: printf("\b \b");
953: *bp = NUL;
954: }
955: for ( ; (bp >= cmdbuf) && (*bp != SP) ; bp--) {
956: printf("\b \b");
957: *bp = NUL;
958: }
959: bp++;
960: inword = 0;
961: return(cmflgs = -1);
962: }
963: if (c == RDIS) { /* ^R, redisplay */
964: *bp = NUL;
965: printf("\n%s%s",cmprom,cmdbuf);
966: continue;
967: }
968: }
969: if (echof) putchar(c); /* If tty input, echo. */
970: inword = 1; /* Flag we're in a word. */
971: if (quote == 0 || c != NL) *bp++ = c; /* And deposit it. */
972: quote = 0; /* Turn off quote. */
973: } /* end of big while */
974: putchar(BEL); /* Get here if... */
975: printf("\n?Buffer full\n");
976: return(cmflgs = -2);
977: }
978:
979:
980: /* Utility functions */
981:
982: /* A D D B U F -- Add the string pointed to by cp to the command buffer */
983:
984: addbuf(cp) char *cp; {
985: int len = 0;
986: while ((*cp != NUL) && (bp < cmdbuf+CMDBL)) {
987: *bp++ = *cp++; /* Copy and */
988: len++; /* count the characters. */
989: }
990: *bp++ = SP; /* Put a space at the end */
991: *bp = NUL; /* Terminate with a null */
992: np = bp; /* Update the next-field pointer */
993: return(len); /* Return the length */
994: }
995:
996: /* S E T A T M -- Deposit a string in the atom buffer */
997:
998: setatm(cp) char *cp; {
999: char *ap;
1000: cc = 0;
1001: ap = atmbuf;
1002: *ap = NUL;
1003: while (*cp == SP) cp++;
1004: while ((*cp != SP) && (*cp != NL) && (*cp != NUL) && (*cp != CR)) {
1005: *ap++ = *cp++;
1006: cc++;
1007: }
1008: *ap++ = NUL;
1009: return(cc); /* Return length */
1010: }
1011:
1012: /* D I G I T S -- Verify that all the characters in line are digits */
1013:
1014: digits(s) char *s; {
1015: while (*s) {
1016: if (!isdigit(*s)) return(0);
1017: s++;
1018: }
1019: return(1);
1020: }
1021:
1022: /* L O W E R -- Lowercase a string */
1023:
1024: lower(s) char *s; {
1025: int n = 0;
1026: while (*s) {
1027: if (isupper(*s)) *s = tolower(*s);
1028: s++, n++;
1029: }
1030: return(n);
1031: }
1032:
1033: /* T E S T -- Bit test */
1034:
1035: test(x,m) int x, m; { /* Returns 1 if any bits from m are on in x, else 0 */
1036: return((x & m) ? 1 : 0);
1037: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.