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