![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to help.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / help|
Return to help.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / help |
1.1 root 1: /* Copyright (c) 1983 Regents of the University of California */
2:
3: #ifndef lint
4: static char sccsid[] = "@(#)help.c 1.2 (Berkeley) 8/14/85";
5: #endif not lint
6:
7: /*
8: * help - an easy way to find and use information
9: *
10: * Usage: see definition of error()
11: *
12: * Files: /usr/lib/help root help subsystem
13: * /usr/lib/help/log log of system activity
14: * /usr/lib/help/maint help maintenance scripts
15: * /usr/lib/help/config defines the help system network
16: * /usr/lib/help/src nroff sources for /usr/lib/help/cat
17: * /usr/lib/help/cat root of system help topic files
18: * "/index_{help,man,doc} topics created by mkhelpindex
19: * "/general description of 'help'
20: * "/* all other files are 'help' text files
21: *
22: * Author: John Kunze, UCB (sorting routines based on David Wasley's originals)
23: */
24:
25: #include <sys/types.h>
26: #include <sys/stat.h>
27: #include <sys/dir.h>
28: #include <setjmp.h>
29: #include <signal.h>
30: /* #include <whoami.h> */ /* this would have defined BSD4_2 */
31: #define BSD4_2 1
32: #include <ctype.h>
33: #include <stdio.h>
34:
35: /* user-instruction return codes */
36:
37: #define LIST_I 1
38: #define PASS_I 2
39: #define SAVE_I 3
40: #define TYPE_I 4
41: #define JUNK_I 5
42: #define BACK_I 6
43: #define LPRT_I 7
44: #define HELP_I 8
45: #define ROOT_I 9
46: #define YELL_I 10
47: #define QUIT_I 11
48: #define FIND_I 12
49: #define FLAG_I 13
50: #define NOOP_I 14
51: #define GOT_ONE 15
52:
53: /* symbols and macros */
54:
55: #define HDBSIZE 256
56: #define HVSIZE 10
57: #define HELPROOT "/usr/lib/help/cat"
58: #define TOPICINDEX "index_help"
59: #define HELPMAINT "../maint/do."
60: #ifdef notdef
61: #define MANINDEX "/usr/lib/whatis"
62: #else
63: #define MANINDEX { "/usr/lib/whatis", "/usr/man/whatis", NULL }
64: #endif
65: #define DOCINDEX "/usr/lib/help/cat/index_doc"
66: #define HELPSAVE "helpsave"
67: #ifdef notdef
68: #define MAINTAINER "help@ucbopal"
69: #else
70: #define MAINTAINER "help"
71: #endif
72: #define HELPLOG "/usr/lib/help/log"
73: #define DEFSHELL "/bin/csh"
74: #define PERROR { perror("help"); exit(1); }
75: #define PUTNL { putchar('\n'); fflush(stdout); }
76: #define EXISTS(s) (access(s, 0) == 0)
77: #define EXECABLE(s) (access(s, 1) == 0)
78: #define WRITABLE(s) (access(s, 2) == 0)
79: #define READABLE(s) (access(s, 4) == 0)
80: #define DOT(s) ((s)[0]=='.'&&(s)[1]==0 ? 1 : 0)
81: #define DOTDOT(s) ((s)[0]=='.'&&(s)[1]=='.'&&(s)[2]==0 ? 1 : 0)
82: #define ROOT(s) ((s)[0]=='/'&&(s)[1]==0 ? 1 : 0)
83: #define isspecial(a) (a == '\0' || a == '+' || a == '>' || a == '|')
84: #define lcase(a) (isupper(a) ? tolower(a) : a)
85:
86: /* signal handling interface */
87:
88: #if BSD4_2
89: struct sigvec vec;
90: #define GET_SIGPIPE { vec.sv_handler = onintr; sigvec(SIGPIPE, &vec, 0); }
91: #define SET_SIGPIPE { vec.sv_handler = SIG_DFL; sigvec(SIGPIPE, &vec, 0); }
92: #define NO_RUPTS { vec.sv_handler = SIG_IGN; sigvec(SIGINT, &vec, 0); }
93: #define OK_RUPTS { vec.sv_handler = SIG_DFL; sigvec(SIGINT, &vec, 0); }
94: #else
95: #define GET_SIGPIPE signal(SIGPIPE, onintr)
96: #define SET_SIGPIPE signal(SIGPIPE, SIG_DFL)
97: #define NO_RUPTS signal(SIGINT, SIG_IGN)
98: #define OK_RUPTS signal(SIGINT, SIG_DFL)
99: #ifndef MAXNAMLEN
100: #define MAXNAMLEN 255
101: #endif
102: #endif
103:
104: /* miscellaneous globals */
105:
106: char hdbuf[HDBSIZE]; /* names of top level directores */
107: char *hvec[HVSIZE]; /* pointers to top level directories */
108: char **argp; /* pointer to topic arguments */
109: char *dirlist; /* unparsed list of root directories */
110: char cwd[MAXNAMLEN]; /* current directory */
111: char *dot, *dotdot; /* tail parts of current and parent dirs */
112: char *subdir; /* current subdirectory names */
113: short dirlevel = 0; /* depth from root of current directory */
114: short keeppag; /* for the >& command to keep pagination */
115: char *shell, shellprompt; /* shell and its prompt */
116: char helpprompt[100]; /* help prompt string */
117: char indexprompt[100]; /* help-index prompt string */
118:
119: /*
120: * Topic names at the top (zero-th) directory level are stored permanently
121: * as null terminated strings in the first segment of topicbuf, each of which
122: * is pointed to by a pointer in the first segment of tptrs. When a subtopic
123: * at any directory level is under inspection, the second segment of topicbuf,
124: * beginning with topicbuf[rtlen], contains the subtopic names, and the second
125: * segment of tptrs, beginning with tptrs[subt], contains pointers to them.
126: * At all times, tptrs[nt] contains zero to mark the end of the active segment.
127: */
128:
129: char topicbuf[4096]; /* null-terminated topic names */
130: char *tptrs[256]; /* pointers to topic names */
131: char **topics; /* points to topics or subtopics */
132: int nt = 0, tlen = 0; /* number and total length of topics */
133: int subt; /* subtopic index in tptrs */
134: int rtlen; /* length of root topics names */
135: int nhits = 0, hit = -1; /* number and index of matched topics */
136:
137: /*
138: * Index references are stored in indexbuf, those for "help" preceding those
139: * for "man", which start at iptrs[mansegment] and precede those for off-line
140: * references starting at iptrs[docsegment]. Each iptrs[i] points to a pair
141: * of null-terminated strings containing the first and second halves of a line.
142: */
143:
144: char *indexbuf; /* names of index references */
145: char **iptrs; /* pointers to index references */
146: int ni = 0, ilen = 0; /* number and length of index refs */
147: int inhits = 0, ihit = -1; /* number and index of matched index refs */
148: char *isrc, *idst; /* partial match of index entry */
149: int mansegment; /* beginning of UPM refs segment */
150: int docsegment; /* beginning of off-line refs segment */
151:
152: char line[BUFSIZ]; /* raw user instruction */
153: char *src, *dst, *dstarg; /* source and dst parts of an instruction */
154: char fname[BUFSIZ]; /* full path name(s) of topic file */
155: short fnamect; /* number of files in fname */
156: short interactive, iflag; /* interactive session flag */
157: short number, quiet; /* numbers accepted/printed, terse prompt */
158: char *more_d; /* pointer to value of MORE env. variable */
159: char *progname; /* name (argv[0]) of invoking program */
160: char *maintkey; /* help maintenance key */
161:
162: /* miscellaneous routines */
163:
164: char *getenv(), *strcpy(), *malloc(), *index(), *rindex();
165: FILE *outpipe();
166:
167: main(argc,argv)
168: int argc;
169: char **argv;
170: {
171: register int ins; /* current user instruction */
172: register int junkcount = 0; /* how many times in a row bad ins. */
173:
174: setbuf(stdout, malloc(BUFSIZ)); /* speed up standard output */
175: setbuf(stderr, malloc(BUFSIZ)); /* speed up error output */
176: getoptions(argc, argv); /* parse options */
177: setgetenv(); /* make directory list, environment */
178:
179: /*
180: * main loop: get instruction, execute
181: */
182: for (ins = startup(); ins != QUIT_I; ins = nextins()) {
183: if (ins != JUNK_I)
184: junkcount = 0;
185: switch (ins) {
186: case LIST_I:
187: list();
188: break;
189: case TYPE_I:
190: if (isadir(fname)) {
191: chwd(src);
192: list();
193: }
194: else
195: page();
196: log('=');
197: break;
198: case BACK_I:
199: chwd("..");
200: list();
201: break;
202: case ROOT_I:
203: chwd("/");
204: list();
205: break;
206: case SAVE_I:
207: save();
208: log('>');
209: break;
210: case LPRT_I:
211: lprt();
212: log('|');
213: break;
214: case PASS_I:
215: fflush(stdout);
216: pass(src);
217: break;
218: case FLAG_I:
219: flag(src, dst);
220: break;
221: case JUNK_I:
222: printf("\nI%sdon't understand.\n",
223: (junkcount++ ? " still " : " "));
224: if (junkcount == 2)
225: list();
226: else if (junkcount > 2)
227: comlist();
228: break;
229: case HELP_I:
230: comlist();
231: break;
232: case YELL_I:
233: yell();
234: break;
235: case FIND_I:
236: find(src);
237: log('+');
238: break;
239: case NOOP_I:
240: break;
241: default:
242: puts("Unknown instruction - please report this.");
243: exit(0);
244: break;
245: }
246: }
247: puts("Bye.");
248: }
249:
250: save() /* save a help file "src" in user file "dst" */
251: {
252: register char *p;
253: register FILE *destfile;
254: register int lcount;
255: char c;
256:
257: p = (EXISTS(dst) ? "appended" : "new file");
258: if ((destfile = fopen(dst, "a")) == NULL)
259: perror(dst);
260: lcount = putfiles(NULL, destfile);
261: fclose(destfile);
262: printf("\nTopic \"%s\" is saved in \"%s\" (%s: %d lines).\n",
263: topics[hit], dst, p, lcount);
264: }
265:
266: lprt() /* lineprint (dst) all args in fname */
267: {
268: register int i = 0;
269: register char *fn;
270: char *ap[HVSIZE]; /* arg pointers */
271:
272: ap[i++] = dst;
273: if (strcmp(dst, "ipr") == 0) /* kludge to force -p with ipr */
274: ap[i++] = "-p";
275: if (dstarg) /* kludge to allow an option to lpr */
276: ap[i++] = dstarg;
277: fn = fname;
278: while (fnamect--) {
279: ap[i++] = fn;
280: fn += strlen(fn) + 1;
281: }
282: ap[i] = 0;
283: if (!fork()) {
284: fputs("\n>> Executing [", stdout);
285: for (i = 0; ap[i]; fputs(ap[i++], stdout))
286: putchar(' ');
287: puts(" ] ...");
288: fflush(stdout);
289: execvp(dst, ap);
290: PERROR;
291: }
292: NO_RUPTS;
293: wait(0);
294: puts(">> Done.");
295: OK_RUPTS;
296: }
297:
298: yell() /* send complaints or other input to the MAINTAINER of help */
299: {
300: if (!fork()) {
301: printf("\n%s\n%s\n%s\n",
302: "Please enter your remarks. The only way I will know you're done is if",
303: "you enter a . (period) or control-d on a line by itself. Don't forget!");
304: fflush(stdout);
305: execlp("mail", "mail", MAINTAINER, 0);
306: PERROR;
307: }
308: NO_RUPTS;
309: wait(0);
310: puts("\nDuly noted.");
311: OK_RUPTS;
312: }
313:
314: log(insc) /* to turn logging off, deny write access of HELPLOG */
315: char insc; /* instruction code character to be written */
316: {
317: long logtime;
318: char *ctime();
319: FILE *lp;
320:
321: if ((lp = fopen(HELPLOG, "a")) == NULL)
322: return;
323: time(&logtime);
324: fprintf(lp, "%.12s %c %s\n", ctime(&logtime) + 4, insc, src);
325: fclose(lp);
326: }
327:
328: getoptions(ac, av) /* get command-line options */
329: int ac; /* spaces need not separate -[dpm] from next arg */
330: register char **av;
331: {
332: register char *p;
333:
334: interactive = isatty(1);
335: progname = *av;
336: for (p = progname; *p; p++);
337: for (p--; p >= progname && *p != '/'; p--);
338: progname = ++p; /* set progname to its tail part */
339: while (**++av == '-')
340: switch (*(p = *av + 1)) {
341: case 'd':
342: if (*++p || *++av)
343: dirlist = (*p ? p : *av);
344: else
345: error("Directory list must follow -d.");
346: break;
347: case 'p':
348: if (*++p || *++av)
349: progname = (*p ? p : *av);
350: else
351: error("Prompt string must follow -p.");
352: break;
353: case 'm':
354: if (*++p || *++av)
355: maintkey = (*p ? p : *av);
356: else {
357: maintkey = "default";
358: av--;
359: }
360: break;
361: case 'i':
362: iflag = interactive = 1;
363: break;
364: case 'n':
365: number = 1;
366: break;
367: case 'q':
368: quiet = 1;
369: break;
370: default:
371: printf("Unknown option -%c.\n", *p);
372: break;
373: }
374: argp = av;
375: }
376:
377: error(msg) /* print a message for command-line errors */
378: char *msg;
379: {
380: if (*msg)
381: fprintf(stderr, "%s\n", msg);
382: fprintf(stderr, "Usage: help [ options ] [ topic [ subtopic [ subsubtopic [...] ] ] ]\n");
383: fprintf(stderr, "Options are:\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n",
384: "-d dirlist override the default pool of help files",
385: "-m key do the help maintenance function given by key",
386: "-p prompt override the default prompt",
387: "-i force help to be interactive",
388: "-n use numbers in topic and index listings",
389: "-q suppress the instruction line before prompting");
390: fprintf(stderr, "To get started just type \"help\".\n");
391: exit(1);
392: }
393:
394: helpmaint(key, dir, av) /* invoke maintenance script */
395: char *key; /* key specifying action */
396: char *dir; /* first writable dir in HELPPOOL */
397: char **av; /* topics, if any */
398: {
399: char s[BUFSIZ];
400: char *argv[BUFSIZ];
401: register char **vp = argv;
402:
403: sprintf(s, "%s/%s%s", dir, HELPMAINT, key);
404: if (!READABLE(s)) {
405: printf("I don't know how to do \"%s\".\n", key);
406: fflush(stdout);
407: sprintf(s, "%s/%s%s", dir, HELPMAINT, "default");
408: }
409: *vp++ = "csh";
410: *vp++ = "-f";
411: *vp++ = s;
412: *vp++ = dir;
413: while (*av)
414: *vp++ = *av++;
415: *vp = 0;
416: execv("/bin/csh", argv);
417: PERROR;
418: }
419:
420: setgetenv() /* get directory list and shell, and set more -d for man */
421: {
422: register char *p = dirlist, **vp;
423: register int i = 0;
424: char **myenv; char *t; int moredef = 0;
425: extern char **environ;
426:
427: for (vp = environ; *vp; vp++)
428: if (strncmp(*vp, "HELPPOOL=", 9) == 0 && !p)
429: p = *vp + 9;
430: else if (strncmp(*vp, "SHELL=", 6) == 0)
431: shell = *vp + 6;
432: else if (strncmp(*vp, "MORE=", 5) == 0)
433: moredef++;
434: if (p) {
435: t = &hdbuf[0];
436: while (*p) {
437: hvec[i++] = t;
438: while (*p == ':' || isspace(*p))
439: p++;
440: while (*p && *p != ':' && !isspace(*p))
441: *t++ = *p++;
442: *t++ = 0;
443: }
444: }
445: if (!dirlist)
446: hvec[i++] = HELPROOT;
447: hvec[i] = 0;
448: if (!shell)
449: shell = DEFSHELL;
450: shellprompt = (strcmp(shell, DEFSHELL) == 0 ? '%' : '$');
451: if (number)
452: sprintf(helpprompt,
453: "\nTo see a topic, type its name or number, and RETURN; '%c' to quit, '?' for help.", shellprompt);
454: else
455: sprintf(helpprompt,
456: "\nTo display a topic, type its name, and RETURN; type '%c' to quit, '?' for help.", shellprompt);
457: if (number)
458: sprintf(indexprompt,
459: "\nTo display a subject, type its name or number, and RETURN; type '?' for help.", shellprompt);
460: else
461: sprintf(indexprompt,
462: "\nTo display a subject, type its name, and RETURN; type '?' for help.", shellprompt);
463: if (moredef)
464: return;
465: myenv = (char **) malloc((vp - environ + 2) * sizeof (char *));
466: if (!myenv)
467: PERROR;
468: *myenv = (quiet ? "MORE= " : "MORE=-d");
469: more_d = *myenv + 5; /* points to "-d" or " " */
470: for (i = 0, vp = myenv + 1; environ[i]; i++, vp++)
471: *vp = environ[i];
472: environ = myenv;
473: }
474:
475: startup() /* get topic named by args, return first instruction */
476: {
477: register int i, ins;
478: char **t, **u;
479:
480: if (maintkey) {
481: for (i = 0; hvec[i]; i++)
482: if (WRITABLE(hvec[i]) && isadir(hvec[i]))
483: break;
484: if (!hvec[i]) {
485: fprintf(stderr, "You need write permission in at least one directory in HELPPOOL.\n");
486: exit(1);
487: }
488: helpmaint(maintkey, hvec[i], argp); /* no return */
489: }
490: for (i = 0; hvec[i]; i++) /* collect first level (root) */
491: getfiles(hvec[i]); /* topics to be kept permanently */
492: rtlen = tlen; /* save root topic sizes */
493: topics = tptrs; /* active topic segment */
494: vsort(tptrs); /* sort -- replace dups with zero */
495: t = u = tptrs; /* kill off zeros */
496: while (t < tptrs + nt)
497: if (!*t)
498: t++;
499: else
500: *u++ = *t++;
501: *u = 0; /* mark new end of first segment */
502: nt = u - tptrs; /* so tptrs[nt-1] is nil */
503: subt = nt + 1; /* mark start of subtopic segment */
504: for (; *argp; argp++) { /* go through topic arguments */
505: if (!match(*argp)) /* if no match, try something else */
506: if ((ins = whatnext(*argp)) != GOT_ONE)
507: return ins; /* user can escape this way */
508: if (!chwd(topics[hit])) /* if match, assume it's a directory */
509: break; /* not a directory, must be a file */
510: }
511: if (!*argp)
512: return LIST_I;
513: src = topics[hit];
514: makefname(dirlevel, topics[hit]);
515: page();
516: if (!iflag)
517: exit(0);
518: interactive = 1;
519: return NOOP_I;
520: }
521:
522: whatnext(s) /* match s with a file or find out what to do */
523: char *s; /* if success, global src set from s */
524: {
525: static char word[MAXNAMLEN];
526: char rbuf[10];
527: int wlen;
528:
529: strcpy(word, s);
530: src = word;
531: do {
532: if (!interactive) {
533: printf("\nThere is no topic \"%s\". I'm looking in the index.\n", word);
534: fflush(stdout);
535: return FIND_I;
536: }
537: else if (nhits > 1) {
538: printf("\nNot precise enough. Enter more letters, or RETURN: %s", word);
539: fflush(stdout);
540: wlen = strlen(word);
541: if (gets(word + wlen) == NULL)
542: return QUIT_I;
543: if (strlen(word) <= wlen) /* no new letters */
544: return NOOP_I;
545: }
546: else {
547: printf("\nThere is no topic \"%s\". Shall I look in the index? ", word);
548: fflush(stdout);
549: if (gets(rbuf) == NULL)
550: return QUIT_I;
551: if (*rbuf == 'y')
552: return FIND_I;
553: return NOOP_I;
554: }
555: } while (!match(word));
556: src = topics[hit];
557: return GOT_ONE;
558: }
559:
560: char *cwdend = cwd; /* end of current directory string */
561:
562: chwd(s) /* change directory routine */
563: register char *s;
564: {
565: register char *p;
566: register int i;
567:
568: if (DOT(s))
569: return 1;
570: if (DOTDOT(s)) {
571: if (dirlevel == 0)
572: return !printf("\nYou're at the top level already.\n");
573: while (*--cwdend != '/');
574: *cwdend = 0;
575: dirlevel--;
576: }
577: else if (ROOT(s)) {
578: if (dirlevel == 0)
579: return !printf("\nYou're at the top level already.\n");
580: dirlevel = 0;
581: }
582: else if (dirlevel > 0) {
583: strcat(strcat(cwdend, "/"), s);
584: if (!EXECABLE(cwd) || !isadir(cwd))
585: return *cwdend = 0;
586: while (*++cwdend);
587: dirlevel++;
588: }
589: else {
590: for (i = 0; hvec[i]; i++) {
591: cwdend = strcpy(cwd, hvec[i]);
592: while (*++cwdend);
593: subdir = cwdend;
594: strcat(strcat(cwdend, "/"), s);
595: if (EXECABLE(cwd) && isadir(cwd))
596: break;
597: *cwdend = 0;
598: subdir = 0;
599: }
600: if (!hvec[i])
601: return 0;
602: while (*++cwdend);
603: dirlevel++;
604: }
605:
606: /*
607: * reclaim subtopic storage, get new topics
608: */
609: nhits = 0; hit = -1; tlen = rtlen;
610: if (dirlevel > 0) {
611: nt = subt;
612: topics = tptrs + subt;
613: getfiles(cwd);
614: vsort(topics);
615: }
616: else {
617: nt = subt - 1;
618: topics = tptrs;
619: subdir = 0;
620: }
621: return 1;
622: }
623:
624: nextins() /* sets up globals: src, dst, and fname */
625: {
626: register char *p, *s;
627: register int ins, got_one = 0;
628: char c = 0;
629:
630: /*
631: * initialize fname, src, dst, and keeppag; get instruction
632: */
633: if (!interactive)
634: return QUIT_I;
635: fname[0] = 0;
636: src = dst = dstarg = 0;
637: keeppag = 0;
638: prompt();
639: if (gets(line) == NULL)
640: return QUIT_I;
641:
642: /*
643: * trim blanks from end and beginning of line
644: */
645: for (p = line+strlen(line)-1; isspace(*p) && p >= line; p--);
646: if (p < line)
647: return NOOP_I;
648: *++p = 0;
649: for (p = line; isspace(*p); p++);
650:
651: /*
652: * parse zero operand instructions
653: */
654: if (*p == '?')
655: return HELP_I;
656: if (*p == '/')
657: return ROOT_I;
658: if (DOT(p))
659: return LIST_I;
660: if (DOTDOT(p))
661: return BACK_I;
662: if (*p == '%' || *p == '$')
663: return QUIT_I;
664: if (*p == '<')
665: return YELL_I;
666:
667: /*
668: * other instructions
669: */
670: if (*p == '!') {
671: src = ++p;
672: return PASS_I;
673: }
674: if (*p == '*') {
675: for (p++; isspace(*p); p++);
676: if (*p)
677: src = p;
678: for (; *p && !isspace(*p); p++);
679: if (*p)
680: *p++ = 0;
681: for (; *p && isspace(*p); p++);
682: if (*p)
683: dst = p;
684: return FLAG_I;
685: }
686: if (*p == '=') { /* = as topic */
687: p++;
688: if (hit < 0)
689: return JUNK_I;
690: }
691: else if (number && isdigit(*p)) {
692: for (s = p; *p; p++)
693: if (!isdigit(*p))
694: break;
695: hit = atoi(s) - 1;
696: if (hit < 0 || hit >= (dirlevel == 0 ? nt : nt - subt)) {
697: printf("\nThere is no topic numbered %d.\n", atoi(s));
698: return NOOP_I;
699: }
700: got_one++;
701: src = topics[hit];
702: makefname(dirlevel, topics[hit]);
703: for (; isspace(*p); p++);
704: }
705: else if (isalpha(*p) || *p == '.' || *p == '-') { /* put topic name in src */
706: src = p;
707: for (; !isspecial(*p) && !isspace(*p); p++);
708: for (; isspace(*p); p++)
709: *p = 0; /* make sure it ends */
710: }
711: c = *p;
712: *p++ = 0;
713: if (!src) { /* no topic, see if default exists */
714: if (hit < 0) {
715: printf("\nYou need to give a topic name for that.");
716: return JUNK_I;
717: }
718: src = topics[hit];
719: }
720: if (c == '>' || c == '|') { /* more args allowed */
721: for (; isspace(*p); p++);
722: if (*p == '&') {
723: keeppag = 1;
724: for (p++; isspace(*p); p++);
725: }
726: if (!*p)
727: strcat(p, (c == '>' ? HELPSAVE : "lpr"));
728: dst = p;
729: for (; *p && !isspace(*p); p++);
730: for (; *p && isspace(*p); p++)
731: *p = 0; /* terminate dst */
732: if (*p) {
733: dstarg = p;
734: for (; *p && !isspace(*p); p++);
735: *p = 0; /* terminate dstarg */
736: }
737: }
738:
739: /*
740: * instructions requiring src
741: */
742: if (c == '+')
743: return FIND_I;
744: if (!got_one) {
745: if (!match(src) && (ins = whatnext(src)) != GOT_ONE)
746: return ins;
747: src = topics[hit];
748: makefname(dirlevel, topics[hit]);
749: }
750: if (!c)
751: return TYPE_I;
752: if (c == '|')
753: return LPRT_I;
754: if (c == '>')
755: return SAVE_I;
756: return JUNK_I;
757: }
758:
759: prompt() /* prompt user */
760: {
761: register char *p;
762:
763: if (!quiet)
764: fputs(helpprompt, stdout);
765: fputs("\n(", stdout);
766: fputs(progname, stdout);
767: if (subdir)
768: for (p = subdir; *p; p++)
769: if (*p == '/')
770: putchar(' ');
771: else
772: putchar(*p);
773: fputs(") ", stdout);
774: fflush(stdout);
775: }
776:
777: substr(s, abbr) /* returns 1 if abbr abbreviates s */
778: register char *s, *abbr;
779: {
780: for (; *s == *abbr && *abbr; s++, abbr++);
781: return !*abbr;
782: }
783:
784: fsubstr(s, abbr) /* returns 1 if abbr abbreviates lcased s */
785: register char *s, *abbr;
786: {
787: for (; lcase(*s) == *abbr && *abbr; s++, abbr++);
788: return !*abbr;
789: }
790:
791: getfiles(dname) /* fill topicbuf and tptrs */
792: char *dname;
793: {
794: struct direct dbuf;
795: register struct direct *ep = &dbuf; /* directory entry pointer */
796: register int i;
797: #if BSD4_2
798: DIR *dp;
799: #define OPENDIR(s) ((dp = opendir(s)) != NULL)
800: #define DIRLOOP(s) for (s = readdir(dp); s != NULL; s = readdir(dp))
801: #define PATHSIZE 256
802: #define PATHSIZE 256
803: #define MAXDLEN ep->d_namlen
804: #define CLOSEDIR closedir(dp)
805: #else
806: int fd;
807: #define OPENDIR(s) ((fd = open(s, 0)) >= 0)
808: #define DIRLOOP(s) while (read(fd, s, sizeof *s) == sizeof *s)
809: #define MAXDLEN DIRSIZ
810: #define CLOSEDIR close(fd)
811: #endif
812:
813: if (!OPENDIR(dname))
814: return perror(dname);
815: tptrs[nt] = &topicbuf[tlen];
816: DIRLOOP(ep) {
817: if (ep->d_name[0] == NULL || ep->d_ino == 0
818: || DOT(ep->d_name) || DOTDOT(ep->d_name))
819: continue;
820: tptrs[nt++] = &topicbuf[tlen];
821: for (i = 0; i < MAXDLEN && ep->d_name[i]; tlen++, i++)
822: topicbuf[tlen] = ep->d_name[i];
823: topicbuf[tlen++] = 0;
824: }
825: tptrs[nt] = 0;
826: CLOSEDIR;
827: }
828:
829: isadir(name)
830: char *name;
831: {
832: struct stat buf;
833:
834: stat(name, &buf);
835: return buf.st_mode & S_IFDIR;
836: }
837:
838: jmp_buf jmpenv;
839:
840: onintr() /* catch broken pipe signals */
841: {
842: NO_RUPTS;
843: SET_SIGPIPE;
844: longjmp(jmpenv, 1);
845: }
846:
847: wrapup(fp) /* close a file pointer and wait for child */
848: FILE *fp;
849: {
850: fclose(fp);
851: wait(0);
852: OK_RUPTS;
853: }
854:
855: int firstime = 1; /* for first topic listing */
856:
857: list() /* list topics in 4 columns */
858: {
859: register int col, row, i, last, nrows;
860: FILE *more;
861:
862: fflush(stdout);
863: NO_RUPTS;
864: if ((more = outpipe()) == NULL)
865: PERROR;
866: if (setjmp(jmpenv)) {
867: wrapup(more);
868: return;
869: }
870: GET_SIGPIPE;
871: if (firstime) {
872: fprintf(more, "\n%s\n%s\n",
873: "Here is a list of topics I know about.",
874: "If you don't see the topic you want, I can look for it in the index.");
875: if (match("general"))
876: fprintf(more, "For a general introduction, please see \"general\" below.\n");
877: firstime = 0;
878: }
879: fputc('\n', more);
880: last = (dirlevel > 0 ? nt - subt : nt);
881: nrows = last / 4 + (last % 4 != 0 ? 1 : 0);
882: for (row = 0; row < nrows; row++)
883: for (i = row, col = 0; col < 4; i += nrows, col++) {
884: if (i >= last) {
885: fputc('\n', more);
886: col = 3;
887: }
888: else if (number)
889: fprintf(more, "%3d%c%-14.14s %c",
890: i + 1,
891: (hit == i ? '=' : ' '),
892: topics[i], (col == 3 ? '\n' : ' '));
893: else
894: fprintf(more, "%c%-17.17s %c",
895: (hit == i ? '=' : ' '),
896: topics[i], (col == 3 ? '\n' : ' '));
897: }
898: wrapup(more);
899: }
900:
901: #define IBSIZE 16384
902: #define IPSIZE 512
903:
904: find(s)
905: char *s;
906: {
907: register char *p;
908: register int i;
909: FILE *fp, *popen();
910: char sbuf[BUFSIZ];
911:
912: if (!iptrs) { /* malloc storage once and for all */
913: indexbuf = (char *) malloc(IBSIZE + BUFSIZ);
914: iptrs = (char **) malloc((IPSIZE + 32) * sizeof(char *));
915: if (iptrs == 0 || indexbuf == 0) {
916: fprintf(stderr, "No index space.\n");
917: exit(1);
918: }
919: }
920: ni = 0; ilen = 0;
921: for (i = 0; hvec[i]; i++) {
922: sprintf(sbuf, "%s/%s", hvec[i], TOPICINDEX);
923: if ((fp = fopen(sbuf, "r")) == NULL) {
924: if (strcmp(hvec[i], HELPROOT) == 0) {
925: perror(sbuf);
926: exit(1);
927: }
928: continue;
929: }
930: getrefs(fp, 0);
931: fclose(fp);
932: }
933: #ifdef notdef
934: if ((fp = fopen(MANINDEX, "r")) == NULL) {
935: perror(MANINDEX);
936: exit(1);
937: }
938: mansegment = ni;
939: getrefs(fp, 1);
940: fclose(fp);
941: #else
942: {
943: static char *manindex[] = MANINDEX;
944: register char **mi;
945:
946: mansegment = ni;
947:
948: for (mi = manindex; *mi != NULL; mi++)
949: if ((fp = fopen(*mi, "r")) != NULL) {
950: getrefs(fp, 1);
951: fclose(fp);
952: break;
953: }
954: }
955: #endif
956: docsegment = ni;
957: if ((fp = fopen(DOCINDEX, "r")) != NULL) {
958: getrefs(fp, 0);
959: fclose(fp);
960: }
961: if (ni == 0)
962: return printf("\nNo relevant material; your request has been logged.\n");
963: putrefs();
964: if (!interactive)
965: exit(0);
966: while ((i = selectref()) != QUIT_I)
967: switch (i) {
968: case LIST_I:
969: putrefs();
970: break;
971: case HELP_I:
972: icomlist();
973: break;
974: case ROOT_I:
975: chwd("/");
976: case BACK_I:
977: list();
978: return;
979: case YELL_I:
980: yell();
981: break;
982: case PASS_I:
983: fflush(stdout);
984: pass(isrc);
985: break;
986: case FLAG_I:
987: flag(isrc, idst);
988: break;
989: default:
990: break;
991: }
992: puts("Bye.");
993: exit(0);
994: }
995:
996: icomlist()
997: {
998: if (number)
999: puts("\nTo see a subject, type its name, a unique abbreviation, or its number.");
1000: else
1001: puts("\nTo see a subject, type its name or a unique abbreviation.");
1002: puts("Other commands are:");
1003: printf(" %c quit from help and return to the shell (control-d works also)\n", shellprompt);
1004: printf(" subject display a \"subject\", whose name%syou supply\n",
1005: (number ? " or number " : " "));
1006: puts(" ? display this command list");
1007: puts(" . list subject references found");
1008: puts(" .. go back to the previous list of help topics");
1009: puts(" / back up to and list the top level of topics");
1010: puts(" < send comments or other input to the maintainer of help");
1011: puts(" !command do a Unix command and then return to help");
1012: puts(" * flag on/off set a \"flag\" on or off to adjust the behavior of help");
1013: puts(" (type * by itself for a list of flags you can use)");
1014: puts("The Unix command in brackets below each subject will display the same");
1015: puts("information that I do. Sometimes information exists only off-line and I");
1016: puts("have nothing to show you; try the local distributor of printed documentation.");
1017: }
1018:
1019: getrefs(fp, upm) /* get references to src from indexes qq.v. */
1020: FILE *fp;
1021: int upm; /* whether looking at upm database "whatis" */
1022: {
1023: /*
1024: * indexbuf str0\0str1\0str2\0str3\0 ... str(ni-1)\0
1025: * iptrs ^ ^ ^ ^ ... ^ 0
1026: */
1027: register char *p, *ref;
1028: char s[MAXNAMLEN]; /* lower case version of src */
1029: char t[BUFSIZ]; /* temporary line buffer */
1030: int preamble = !upm;
1031:
1032: if (ilen > IBSIZE || ni > IPSIZE)
1033: return puts("Index space full.");
1034: for (p = src, ref = s; *p; p++, ref++) /* ref becomes lower case */
1035: *ref = lcase(*p); /* version of src */
1036: *ref = 0;
1037: ref = s;
1038: iptrs[ni] = &indexbuf[ilen];
1039: while (fgets(t, BUFSIZ, fp) != NULL) {
1040: if (preamble) { /* indexes all have preamble to skip */
1041: if ((p = index(t, '-')) && fsubstr(p, "------"))
1042: preamble = 0; /* preamble over */
1043: continue;
1044: }
1045: for (p = t; *p; p++)
1046: if (lcase(*p) == *ref && fsubstr(p, ref))
1047: break;
1048: if (!*p)
1049: continue;
1050: iptrs[ni++] = &indexbuf[ilen];
1051: for (p = t; *p && isspace(*p); p++);
1052: for (; *p && *p != ' '; ilen++, p++)
1053: indexbuf[ilen] = *p;
1054: if (upm)
1055: for (; *p && *p != '\t'; ilen++, p++)
1056: if (*p == '-' && *(p + 1) == ' ')
1057: break; /* cover glitches in MANINDEX */
1058: else
1059: indexbuf[ilen] = *p;
1060: indexbuf[ilen++] = 0;
1061: for (; *p && isspace(*p); p++);
1062: if (upm && *p == '-' && *(p + 1) == ' ')
1063: p += 2;
1064: iptrs[ni++] = &indexbuf[ilen];
1065: for (; *p; ilen++, p++)
1066: indexbuf[ilen] = *p;
1067: indexbuf[ilen++] = 0;
1068: }
1069: iptrs[ni] = 0;
1070: fclose(fp);
1071: }
1072:
1073: putrefs() /* list references stored in iptrs */
1074: {
1075: register int i;
1076: register char *p, *format;
1077: FILE *more;
1078:
1079: NO_RUPTS;
1080: if ((more = outpipe()) == NULL)
1081: PERROR;
1082: if (setjmp(jmpenv)) {
1083: wrapup(more);
1084: return;
1085: }
1086: GET_SIGPIPE;
1087: format = (number ? "%3d %s\t\t[ " : "%s\t\t[ ");
1088: fprintf(more, "\nThese subjects appear to be related to \"%s\".\n\n", src);
1089: for (i = 0; i < ni; i += 2) {
1090: if (number)
1091: fprintf(more, format, (i / 2 + 1), iptrs[i + 1]);
1092: else
1093: fprintf(more, format, iptrs[i + 1]);
1094: if (i < mansegment) {
1095: fputs("help ", more);
1096: for (p = iptrs[i]; *p; p++)
1097: putc((*p == '/' ? ' ' : *p), more);
1098: }
1099: else if (i >= docsegment)
1100: fprintf(more, "Off-line only document: %s", iptrs[i]);
1101: else {
1102: fputs("man ", more);
1103: for (p = iptrs[i]; *p && *p != '('; p++);
1104: for (p++; *p != ')'; p++)
1105: putc(lcase(*p), more);
1106: putc(' ', more);
1107: for (p = iptrs[i]; *p != ',' && *p != ' '; p++)
1108: putc(*p, more);
1109: }
1110: fputs(" ]\n", more);
1111: }
1112: wrapup(more);
1113: }
1114:
1115: FILE *
1116: outpipe() /* return a file descriptor pointing to "more" */
1117: {
1118: int fildes[2];
1119: FILE *fp, *fdopen();
1120:
1121: if (pipe(fildes) == -1)
1122: PERROR;
1123: if (!fork()) {
1124: OK_RUPTS;
1125: close(fildes[1]);
1126: fclose(stdin);
1127: if (dup(fildes[0]) == -1)
1128: PERROR;
1129: close(fildes[0]);
1130: execlp("more", "more", "-s", 0);
1131: PERROR;
1132: }
1133: close(fildes[0]);
1134: return fdopen(fildes[1], "w");
1135: }
1136:
1137: iprompt() /* prompt user - index version */
1138: {
1139: if (!quiet)
1140: fputs(indexprompt, stdout);
1141: printf("\n(%s-index %s) ", progname, src);
1142: fflush(stdout);
1143: }
1144:
1145: selectref() /* read user instruction for indexing */
1146: {
1147: register char *p, *s;
1148: register int ins;
1149: char sbuf[BUFSIZ];
1150:
1151: isrc = idst = 0;
1152: iprompt();
1153: if (gets(sbuf) == NULL)
1154: exit(0);
1155: for (p = sbuf+strlen(sbuf)-1; isspace(*p) && p >= sbuf; p--);
1156: if (p < sbuf)
1157: return NOOP_I;
1158: *++p = 0; /* blanks now trimmed */
1159: for (p = sbuf; isspace(*p); p++);
1160: if (*p == '%' || *p == '$')
1161: return QUIT_I;
1162: if (DOT(p))
1163: return LIST_I;
1164: if (DOTDOT(p))
1165: return BACK_I;
1166: if (*p == '?')
1167: return HELP_I;
1168: if (*p == '/')
1169: return ROOT_I;
1170: if (*p == '<')
1171: return YELL_I;
1172: if (*p == '!') {
1173: isrc = ++p;
1174: return PASS_I;
1175: }
1176: if (*p == '*') {
1177: for (p++; isspace(*p); p++);
1178: if (*p)
1179: isrc = p;
1180: for (; *p && !isspace(*p); p++);
1181: if (*p)
1182: *p++ = 0;
1183: for (; *p && isspace(*p); p++);
1184: if (*p)
1185: idst = p;
1186: return FLAG_I;
1187: }
1188: for (s = p; *s; s++)
1189: if (!isdigit(*s))
1190: break;
1191: if (!*s && number) {
1192: ihit = 2 * atoi(p) - 1;
1193: if (ihit < 1 || ihit > ni) {
1194: printf("\nThere is no subject numbered %d.\n", atoi(p));
1195: return NOOP_I;
1196: }
1197: }
1198: else
1199: if ((ins = iwhatnext(p)) != GOT_ONE)
1200: return ins;
1201: if (ihit < mansegment) {
1202: makefname(0, iptrs[ihit - 1]);
1203: page();
1204: return NOOP_I;
1205: }
1206: if (ihit >= docsegment && docsegment > 0) {
1207: puts("\nSorry, that reference is not available on the computer.");
1208: return NOOP_I;
1209: }
1210: if (!fork()) {
1211: for (s = sbuf, p = iptrs[ihit - 1]; *p != ' ' && *p != ','; p++)
1212: *s++ = *p;
1213: for (; *p != '('; p++);
1214: for (*s++ = 0, p++; *p != ')'; p++)
1215: *s++ = lcase(*p);
1216: for (*s-- = 0; *s; s--);
1217: execlp("man", "man", ++s, sbuf, 0);
1218: PERROR;
1219: }
1220: NO_RUPTS;
1221: wait(0);
1222: OK_RUPTS;
1223: return NOOP_I;
1224: }
1225:
1226: iwhatnext(s) /* indexing version of whatnext */
1227: char *s;
1228: {
1229: static char word[MAXNAMLEN];
1230: int wlen;
1231:
1232: strcpy(word, s);
1233: isrc = word;
1234: while (!imatch(word))
1235: if (inhits > 1) {
1236: printf("\nNot precise enough. Enter more letters, or RETURN: %s", word);
1237: fflush(stdout);
1238: wlen = strlen(word);
1239: if (gets(word + wlen) == NULL)
1240: return QUIT_I;
1241: if (strlen(word) <= wlen) /* no new letters */
1242: return NOOP_I;
1243: }
1244: else {
1245: printf("\nThere is no subject \"%s\".\n", word);
1246: return NOOP_I;
1247: }
1248: isrc = iptrs[ihit];
1249: return GOT_ONE;
1250: }
1251:
1252: imatch(abbr) /* indexing version of match (on unsorted list) */
1253: char *abbr;
1254: {
1255: register char **t;
1256: register char *p = abbr;
1257: register char **last;
1258:
1259: last = iptrs + (docsegment < 0 ? ni : docsegment);
1260: inhits = 0;
1261: for (t = iptrs + 1; t < last; t += 2)
1262: if (**t != *p) /* quickly check first character */
1263: continue;
1264: else if (substr(*t, abbr)) {
1265: inhits++;
1266: ihit = t - iptrs;
1267: if (strcmp(*t, abbr) == 0)
1268: return (inhits = 1);
1269: }
1270: return (inhits == 1);
1271: }
1272:
1273: makefname(dirlev, tail) /* build fname from cwd and tail, return no. matched */
1274: int dirlev; /* directory level */
1275: char *tail; /* tail of pathname to use */
1276: {
1277: register int i;
1278: register char *p;
1279:
1280: if (dirlev > 0) {
1281: sprintf(fname, "%s/%s", cwd, tail);
1282: fnamect = (EXISTS(fname) ? 1 : 0);
1283: return fnamect;
1284: }
1285: fnamect = 0; /* count of number of dirs. where tail exists */
1286: p = fname; /* full names of files with tails as above */
1287: for (i = 0; hvec[i]; i++) {
1288: sprintf(p, "%s/%s", hvec[i], tail);
1289: if (EXISTS(p)) {
1290: fnamect++;
1291: p += strlen(p) + 1;
1292: }
1293: }
1294: return fnamect;
1295: }
1296:
1297: pass(s) /* replace = with fname and send to system */
1298: register char *s; /* allow \= to pass as =, but \x passes as \x */
1299: {
1300: register char *p;
1301: register int escaped = 0;
1302: char buf[BUFSIZ];
1303:
1304: PUTNL;
1305: for (p = buf; *s; s++) {
1306: if (escaped) {
1307: if (*s != '=')
1308: *p++ = '\\';
1309: *p++ = *s;
1310: escaped = 0;
1311: }
1312: else if (*s == '\\')
1313: escaped = 1;
1314: else if (*s == '=' && hit >= 0) {
1315: makefname(dirlevel, topics[hit]);
1316: strcpy(p, fname);
1317: for (; *p; p++);
1318: }
1319: else
1320: *p++ = *s;
1321: }
1322: *p = 0;
1323: if (!fork()) {
1324: putchar('\n');
1325: execl(shell, shell, "-c", buf, 0);
1326: PERROR;
1327: }
1328: NO_RUPTS;
1329: wait(0);
1330: OK_RUPTS;
1331: }
1332:
1333: flag(f, val) /* set flag on or off; 0 in src and dst gives help */
1334: char *f;
1335: char *val;
1336: {
1337: if (!f) {
1338: puts("\nCurrent flag settings and their meanings are:");
1339: printf(" number\t%suse numbers in topic and index listings\n",
1340: (number ? "on\t" : "off\tdo not "));
1341: printf(" quiet \t%ssuppress the instruction line before prompting\n",
1342: (quiet ? "on\t" : "off\tdo not "));
1343: return;
1344: }
1345: if (substr("number", f)) {
1346: printf("\nnumber: was %s,", (number ? "on" : "off"));
1347: if (!val)
1348: number = (number ? 0 : 1); /* toggle */
1349: else
1350: number = (val[1] == 'n' ? 1 : 0);
1351: printf(" is %s.\n", (number ? "on" : "off"));
1352: }
1353: else if (substr("quiet", f)) {
1354: printf("\nquiet: was %s,", (quiet ? "on" : "off"));
1355: if (!val)
1356: quiet = (quiet ? 0 : 1); /* toggle */
1357: else
1358: quiet = (val[1] == 'n' ? 1 : 0);
1359: printf(" is %s.\n", (quiet ? "on" : "off"));
1360: if (more_d)
1361: strcpy(more_d, (quiet ? " " : "-d"));
1362: }
1363: else
1364: puts("\nThat is not a flag I know about. Type * for a complete list.");
1365: }
1366:
1367: page() /* print a help file with more or run program */
1368: {
1369: char c[2];
1370: FILE *fp, *more;
1371:
1372: if ((fp = fopen(fname, "r")) == NULL) {
1373: perror(fname);
1374: return; /* try to continue on this error */
1375: }
1376: c[0] = getc(fp); /* check first 2 characters of first file */
1377: c[1] = getc(fp); /* looking for magic characters and numbers */
1378: /* (should check more than just the first) */
1379: if (runs(c)) { /* if a program, run it and then return */
1380: fclose(fp);
1381: OK_RUPTS;
1382: return;
1383: }
1384: rewind(fp);
1385: NO_RUPTS;
1386: if ((more = outpipe()) == NULL)
1387: PERROR;
1388: if (setjmp(jmpenv)) {
1389: fclose(fp);
1390: wrapup(more);
1391: return;
1392: }
1393: GET_SIGPIPE;
1394: putfiles(fp, more);
1395: fclose(fp);
1396: wrapup(more);
1397: }
1398:
1399: #define isblank(s) (*s == '\n')
1400: #define sqspace(s) { if (!isblank(s) || !wasblank) fputs(s, out); else linect--; wasblank = isblank(s); }
1401:
1402: putfiles(in, out) /* print file(s) onto out file */
1403: FILE *in; /* first of the input files */
1404: FILE *out;
1405: {
1406: register char *fn = fname;
1407: register int linectsum = 0;
1408:
1409: while (fnamect--) {
1410: if (in == NULL && (in = fopen(fn, "r")) == NULL)
1411: perror(fn);
1412: linectsum += filter(in, out);
1413: fclose(in);
1414: in = NULL;
1415: fn += strlen(fn) + 1;
1416: }
1417: return linectsum;
1418: }
1419:
1420: filter(in, out) /* filter out multiple blank lines and page banners */
1421: FILE *in;
1422: FILE *out;
1423: {
1424: char lbuf[BUFSIZ];
1425: register int lineno, wasblank;
1426: register char *s = lbuf;
1427: int linect, i;
1428: char *p;
1429:
1430: /* check page one for proper headers; if none then keep pagination */
1431: wasblank = 0;
1432: for (lineno = 1; fgets(s, BUFSIZ, in) != NULL; lineno++)
1433: if (!isblank(s) || lineno >= 4)
1434: break;
1435: if (!(lineno == 4 &&
1436: (((p = index(s, 'H')) && substr(p, "HELP")) /* help */
1437: || index(s, ')') != rindex(s, ')')))) /* man */
1438: keeppag = 1; /* criteria not met */
1439: if (lineno == 1 && (*s = '#' || *s == ':')) {
1440: keeppag = 1; /* this is a script file */
1441: lineno = 0;
1442: fputc('\n', out);
1443: }
1444: else {
1445: for (i = lineno - 1; i; i--)
1446: if (keeppag)
1447: fputc('\n', out);
1448: else
1449: sqspace("\n");
1450: if (keeppag)
1451: fputs(s, out);
1452: else
1453: sqspace(s);
1454: }
1455: linect = lineno;
1456: while (fgets(s, BUFSIZ, in) != NULL) {
1457: lineno++, linect++;
1458: if (lineno > 66)
1459: lineno = 1;
1460: if (keeppag) /* this global overrides our page 1 analysis */
1461: fputs(s, out);
1462: else if (lineno > 7 && lineno < 60 /* skip page banners */
1463: || linect < 8) /* let first 7 go */
1464: sqspace(s)
1465: }
1466: return linect;
1467: }
1468:
1469: runs(c) /* run program or script named by fname, else return 0 */
1470: char c[];
1471: {
1472: int *magic = (int *)c;
1473:
1474: if (c[0] != '#' && c[0] != ':'
1475: && *magic != 0413 && *magic != 0410 && *magic != 0407)
1476: return 0;
1477: if (!fork()) {
1478: if (*magic == 0413 || *magic == 0410 || *magic == 0407)
1479: execv(fname, 0);
1480: else if (c[0] == '#')
1481: execlp("csh", "csh", "-f", fname, 0);
1482: else
1483: execlp("sh", "sh", fname, 0);
1484: perror(fname);
1485: }
1486: NO_RUPTS;
1487: wait(0);
1488: OK_RUPTS;
1489: return 1;
1490: }
1491:
1492: comlist() /* list help instructions available */
1493: {
1494: if (number)
1495: puts("\nTo see a topic, type its name, a unique abbreviation, or its number.");
1496: else
1497: puts("\nTo see a topic, type its name or a unique abbreviation.");
1498: puts("Here is a list of commands:");
1499: printf(" %c quit from help and return to the shell (control-d works also)\n", shellprompt);
1500: printf(" topic display a \"topic\", whose name%syou supply\n",
1501: (number ? " or number " : " "));
1502: puts(" topic + see what more is known about a topic");
1503: puts(" topic > file save a topic in a file (you supply the name \"file\")");
1504: puts(" topic | lpr paginate and print a topic on the lineprinter");
1505: puts(" topic >& file save a topic in a file with pagination");
1506: puts(" ? display this command list");
1507: puts(" . list topics at the current level");
1508: puts(" .. back up to and list the next higher level of topics");
1509: puts(" / back up to and list the top level of topics");
1510: puts(" < send comments or other input to the maintainer of help");
1511: puts(" !command do a Unix command and then return to help");
1512: puts(" * flag on/off set a \"flag\" on or off to adjust the behavior of help");
1513: puts(" (type * by itself for a list of flags you can use)");
1514: puts("If you enter no topic in a command or just an equals sign (=),");
1515: puts("the most recent topic at this level is used.");
1516: }
1517:
1518: match(abbr) /* find a match for abbr in current directory */
1519: char *abbr;
1520: {
1521: register char **t;
1522: register char *p = abbr;
1523:
1524: nhits = 0;
1525: for (t = topics; *t; t++) /* find first string beginning */
1526: if (**t == *p) /* with same letter */
1527: break;
1528: for (; *t && **t == *p; t++)
1529: if (substr(*t, abbr)) {
1530: nhits++;
1531: hit = t - topics;
1532: if (strcmp(*t, abbr) == 0)
1533: return (nhits = 1);
1534: }
1535: return (nhits == 1);
1536: }
1537:
1538: /*
1539: * radix sort of an alphanumeric list, identical keys deleted
1540: * Originally by D. Wasley, July 1980
1541: */
1542:
1543: #define MSB 0100
1544:
1545: vsort(list)
1546: char *list[];
1547: {
1548: char **endlist = tptrs + nt - 1;
1549: int offset = 0;
1550:
1551: if (endlist > list)
1552: _sortb(list, endlist, 0); /* recursive sort */
1553: }
1554:
1555: _sortb(list, endlist, offset)
1556: char **list, **endlist; int offset;
1557: {
1558: register char **high, c;
1559:
1560: _sortr(list, endlist, offset, MSB); /* radix sort on this char */
1561: while (list < endlist) { /* now sort each sublist that */
1562: c = (*list)[offset]; /* starts with a common char */
1563: high = list;
1564: while ((*++high)[offset] == c && high <= endlist) ;
1565: if (high - list > 1) {
1566: if (c)
1567: _sortb(list, high-1, offset+1);
1568: else /* kill off identical keys */
1569: for (list++; list < high; list++)
1570: *list = 0;
1571: }
1572: list = high;
1573: }
1574: }
1575:
1576: _sortr(list, endlist, offset, mask)
1577: int offset, mask; char **list, **endlist;
1578: {
1579: register char **low, **high, *temp;
1580:
1581: low = list;
1582: high = endlist;
1583: while (low < high) {
1584: while (low < endlist && ((*low)[offset] & mask) == 0)
1585: low++;
1586: while (high > list && ((*high)[offset] & mask) != 0)
1587: high--;
1588: if (high > low) {
1589: temp = *high;
1590: *high = *low;
1591: *low = temp;
1592: }
1593: }
1594: if ((mask >>= 1) != 0) { /* redefine mask and sort sublists */
1595: if (endlist > low)
1596: _sortr(low, endlist, offset, mask);
1597: if (high > list)
1598: _sortr(list, high, offset, mask);
1599: }
1600: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.