![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ask.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to ask.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9: #include "termcap.h"
10: #include "ctype.h"
11: #include <signal.h>
12:
13: #ifdef MAC
14: # include "mac.h"
15: #else
16: # include <varargs.h>
17: # ifdef F_COMPLETION
18: # include <sys/stat.h>
19: # endif
20: #endif /* MAC */
21:
22: #ifdef MAC
23: # undef private
24: # define private
25: #endif
26:
27: #ifdef LINT_ARGS
28: private Buffer * get_minibuf(void);
29: private char * real_ask(char *, int (*)(), char *, char *);
30:
31: private int
32: f_complete(int),
33: bad_extension(char *),
34: crush_bads(char **, int),
35: isdir(char *);
36: private void
37: fill_in(char **, int),
38: EVexpand(void);
39: #else
40: private Buffer * get_minibuf();
41: private char * real_ask();
42:
43: private int
44: f_complete(),
45: bad_extension(),
46: crush_bads(),
47: isdir();
48: private void
49: fill_in(),
50: EVexpand();
51: #endif /* LINT_ARGS */
52:
53: #ifdef MAC
54: # undef private
55: # define private static
56: #endif
57:
58: int AbortChar = CTL('G'),
59: DoEVexpand = NO; /* should we expand evironment variables? */
60:
61: int Asking = NO;
62: char Minibuf[LBSIZE];
63: private Line *CurAskPtr = 0; /* points at some line in mini-buffer */
64: private Buffer *AskBuffer = 0; /* Askbuffer points to actual structure */
65:
66: /* The way the mini-buffer works is this: The first line of the mini-buffer
67: is where the user does his stuff. The rest of the buffer contains
68: strings that the user often wants to use, for instance, file names, or
69: common search strings, etc. If he types C-N or C-P while in ask(), we
70: bump the point up or down a line and extract the contents (we make sure
71: is somewhere in the mini-buffer). */
72:
73: static Buffer *
74: get_minibuf()
75: {
76: if (AskBuffer) { /* make sure ut still exists */
77: register Buffer *b;
78:
79: for (b = world; b != 0; b = b->b_next)
80: if (b == AskBuffer)
81: return b;
82: }
83: AskBuffer = do_select((Window *) 0, "*minibuf*");
84: AskBuffer->b_type = B_SCRATCH;
85: return AskBuffer;
86: }
87:
88: /* Add a string to the mini-buffer. */
89:
90: void
91: minib_add(str, movedown)
92: char *str;
93: {
94: register Buffer *saveb = curbuf;
95:
96: SetBuf(get_minibuf());
97: LineInsert(1);
98: ins_str(str, NO);
99: if (movedown)
100: CurAskPtr = curline;
101: SetBuf(saveb);
102: }
103:
104: /* look for any substrings of the form $foo in linebuf, and expand
105: them according to their value in the environment (if possible) -
106: this munges all over curchar and linebuf without giving it a second
107: thought (I must be getting lazy in my old age) */
108: private void
109: EVexpand()
110: {
111: register int c;
112: register char *lp = linebuf,
113: *ep;
114: char varname[128],
115: *vp,
116: *lp_start;
117: Mark *m = MakeMark(curline, curchar, M_FLOATER);
118:
119: while (c = *lp++) {
120: if (c != '$')
121: continue;
122: lp_start = lp - 1; /* the $ */
123: vp = varname;
124: while (c = *lp++) {
125: if (!isword(c))
126: break;
127: *vp++ = c;
128: }
129: *vp = '\0';
130: /* if we find an env. variable with the right
131: name, we insert it in linebuf, and then delete
132: the variable name that we're replacing - and
133: then we continue in case there are others ... */
134: if (ep = getenv(varname)) {
135: curchar = lp_start - linebuf;
136: ins_str(ep, NO);
137: del_char(FORWARD, strlen(varname) + 1);
138: lp = linebuf + curchar;
139: }
140: }
141: ToMark(m);
142: DelMark(m);
143: }
144:
145: private char *
146: real_ask(delim, d_proc, def, prompt)
147: char *delim,
148: *def,
149: *prompt;
150: int (*d_proc)();
151: {
152: static int InAsk = 0;
153: jmp_buf savejmp;
154: int c,
155: prompt_len;
156: Buffer *saveb = curbuf;
157: int abort = 0,
158: no_typed = 0;
159: data_obj *push_cmd = LastCmd;
160: int o_a_v = arg_value(),
161: o_i_an_a = is_an_arg();
162: #ifdef MAC
163: menus_off();
164: #endif
165:
166: if (InAsk)
167: complain((char *) 0);
168: push_env(savejmp);
169: InAsk += 1;
170: SetBuf(get_minibuf());
171: if (!inlist(AskBuffer->b_first, CurAskPtr))
172: CurAskPtr = curline;
173: prompt_len = strlen(prompt);
174: ToFirst(); /* Beginning of buffer. */
175: linebuf[0] = '\0';
176: modify();
177: makedirty(curline);
178:
179: if (setjmp(mainjmp))
180: if (InJoverc) { /* this is a kludge */
181: abort = YES;
182: goto cleanup;
183: }
184:
185: for (;;) {
186: clr_arg_value();
187: last_cmd = this_cmd;
188: init_strokes();
189: cont: s_mess("%s%s", prompt, linebuf);
190: Asking = curchar + prompt_len;
191: c = getch();
192: if ((c == EOF) || index(delim, c)) {
193: if (DoEVexpand)
194: EVexpand();
195: if (d_proc == (int(*)())0 || (*d_proc)(c) == 0)
196: goto cleanup;
197: } else if (c == AbortChar) {
198: message("[Aborted]");
199: abort = YES;
200: goto cleanup;
201: } else switch (c) {
202: case CTL('N'):
203: case CTL('P'):
204: if (CurAskPtr != 0) {
205: int n = (c == CTL('P') ? -arg_value() : arg_value());
206: CurAskPtr = next_line(CurAskPtr, n);
207: if (CurAskPtr == curbuf->b_first && CurAskPtr->l_next != 0)
208: CurAskPtr = CurAskPtr->l_next;
209: (void) ltobuf(CurAskPtr, linebuf);
210: modify();
211: makedirty(curline);
212: Eol();
213: this_cmd = 0;
214: }
215: break;
216:
217: case CTL('R'):
218: if (def)
219: ins_str(def, NO);
220: else
221: rbell();
222: break;
223:
224: default:
225: dispatch(c);
226: break;
227: }
228: if (curbuf != AskBuffer)
229: SetBuf(AskBuffer);
230: if (curline != curbuf->b_first) {
231: CurAskPtr = curline;
232: curline = curbuf->b_first; /* with whatever is in linebuf */
233: }
234: if (this_cmd == ARG_CMD)
235: goto cont;
236: }
237: cleanup:
238: pop_env(savejmp);
239:
240: LastCmd = push_cmd;
241: set_arg_value(o_a_v);
242: set_is_an_arg(o_i_an_a);
243: no_typed = (linebuf[0] == '\0');
244: strcpy(Minibuf, linebuf);
245: SetBuf(saveb);
246: InAsk = Asking = Interactive = NO;
247: if (!abort) {
248: if (!charp()) {
249: Placur(ILI, 0);
250: flusho();
251: }
252: if (no_typed)
253: return 0;
254: } else
255: complain(mesgbuf);
256: return Minibuf;
257: }
258:
259: /* VARARGS2 */
260:
261: char *
262: ask(def, fmt, va_alist)
263: char *def,
264: *fmt;
265: va_dcl
266: {
267: char prompt[128];
268: char *ans;
269: va_list ap;
270:
271: va_start(ap);
272: format(prompt, sizeof prompt, fmt, ap);
273: va_end(ap);
274: ans = real_ask("\r\n", (int (*)()) 0, def, prompt);
275: if (ans == 0) { /* Typed nothing. */
276: if (def == 0)
277: complain("[No default]");
278: return def;
279: }
280: return ans;
281: }
282:
283: /* VARARGS1 */
284:
285: char *
286: do_ask(delim, d_proc, def, fmt, va_alist)
287: char *delim,
288: *def,
289: *fmt;
290: int (*d_proc)();
291: va_dcl
292: {
293: char prompt[128];
294: va_list ap;
295:
296: va_start(ap);
297: format(prompt, sizeof prompt, fmt, ap);
298: va_end(ap);
299: return real_ask(delim, d_proc, def, prompt);
300: }
301:
302: /* VARARGS1 */
303:
304: int
305: yes_or_no_p(fmt, va_alist)
306: char *fmt;
307: va_dcl
308: {
309: char prompt[128];
310: int c;
311: va_list ap;
312:
313: va_start(ap);
314: format(prompt, sizeof prompt, fmt, ap);
315: va_end(ap);
316: for (;;) {
317: message(prompt);
318: Asking = strlen(prompt); /* so redisplay works */
319: c = getch();
320: Asking = NO;
321: if (c == AbortChar)
322: complain("[Aborted]");
323: switch (CharUpcase(c)) {
324: case 'Y':
325: return YES;
326:
327: case 'N':
328: return NO;
329:
330: default:
331: add_mess("[Type Y or N]");
332: SitFor(10);
333: }
334: }
335: /* NOTREACHED */
336: }
337:
338: #ifdef F_COMPLETION
339: static char *fc_filebase;
340: int DispBadFs = YES; /* display bad file names? */
341: #ifndef MSDOS
342: char BadExtensions[128] = ".o";
343: #else /* MSDOS */
344: char BadExtensions[128] = ".obj .exe .com .bak .arc .lib .zoo";
345: #endif /* MSDOS */
346:
347: static
348: bad_extension(name)
349: char *name;
350: {
351: char *ip,
352: *bads = BadExtensions;
353: int namelen = strlen(name),
354: ext_len,
355: stop = 0;
356:
357: do {
358: if ((ip = index(bads, ' ')) == 0) {
359: ip = bads + strlen(bads);
360: stop = YES;
361: }
362: if ((ext_len = ip - bads) == 0)
363: continue;
364: if ((ext_len < namelen) &&
365: (strncmp(&name[namelen - ext_len], bads, ext_len) == 0))
366: return YES;
367: } while ((bads = ip + 1), !stop);
368: return NO;
369: }
370:
371: int
372: f_match(file)
373: char *file;
374: {
375: int len = strlen(fc_filebase);
376:
377: if (DispBadFs == NO)
378: if (bad_extension(file))
379: return NO;
380:
381: return ((len == 0) ||
382: #ifdef MSDOS
383: (casencmp(file, fc_filebase, strlen(fc_filebase)) == 0)
384: #else
385: (strncmp(file, fc_filebase, strlen(fc_filebase)) == 0)
386: #endif
387: );
388: }
389:
390: static
391: isdir(name)
392: char *name;
393: {
394: struct stat stbuf;
395: char filebuf[FILESIZE];
396:
397: PathParse(name, filebuf);
398: return ((stat(filebuf, &stbuf) != -1) &&
399: (stbuf.st_mode & S_IFDIR) == S_IFDIR);
400: }
401:
402: private void
403: fill_in(dir_vec, n)
404: register char **dir_vec;
405: {
406: int minmatch = 0,
407: numfound = 0,
408: lastmatch = -1,
409: i,
410: the_same = TRUE, /* After filling in, are we the same
411: as when we were called? */
412: is_ntdir; /* Is Newly Typed Directory name */
413: char bads[128];
414:
415: for (i = 0; i < n; i++) {
416: /* if it's no, then we have already filtered them out
417: in f_match() so there's no point in doing it again */
418: if (DispBadFs == YES) {
419: if (bad_extension(dir_vec[i]))
420: continue;
421: }
422: if (numfound)
423: minmatch = min(minmatch,
424: numcomp(dir_vec[lastmatch], dir_vec[i]));
425: else
426: minmatch = strlen(dir_vec[i]);
427: lastmatch = i;
428: numfound += 1;
429: }
430: /* Ugh. Beware--this is hard to get right in a reasonable
431: manner. Please excuse this code--it's past my bedtime. */
432: if (numfound == 0) {
433: rbell();
434: return;
435: }
436: Eol();
437: if (minmatch > strlen(fc_filebase)) {
438: the_same = FALSE;
439: null_ncpy(fc_filebase, dir_vec[lastmatch], minmatch);
440: Eol();
441: makedirty(curline);
442: }
443: is_ntdir = ((numfound == 1) &&
444: (curchar > 0) &&
445: (linebuf[curchar - 1] != '/') &&
446: (isdir(linebuf)));
447: if (the_same && !is_ntdir) {
448: add_mess((n == 1) ? " [Unique]" : " [Ambiguous]");
449: SitFor(7);
450: }
451: if (is_ntdir)
452: insert_c('/', 1);
453: }
454:
455: extern int alphacomp();
456:
457: /* called from do_ask() when one of "\r\n ?" is typed. Does the right
458: thing, depending on which. */
459:
460: static
461: f_complete(c)
462: {
463: char dir[FILESIZE],
464: **dir_vec;
465: int nentries,
466: i;
467:
468: if (c == CR || c == LF)
469: return 0; /* tells ask to return now */
470: #ifndef MSDOS /* kg */
471: if ((fc_filebase = rindex(linebuf, '/')) != 0) {
472: #else /* MSDOS */
473: fc_filebase = rindex(linebuf, '/');
474: if (fc_filebase == (char *)0)
475: fc_filebase = rindex(linebuf, '\\');
476: if (fc_filebase == (char *)0)
477: fc_filebase = rindex(linebuf, ':');
478: if (fc_filebase != (char *)0) {
479: #endif /* MSDOS */
480: char tmp[FILESIZE];
481:
482: fc_filebase += 1;
483: null_ncpy(tmp, linebuf, (fc_filebase - linebuf));
484: if (tmp[0] == '\0')
485: strcpy(tmp, "/");
486: PathParse(tmp, dir);
487: } else {
488: fc_filebase = linebuf;
489: strcpy(dir, ".");
490: }
491: if ((nentries = scandir(dir, &dir_vec, f_match, alphacomp)) == -1) {
492: add_mess(" [Unknown directory: %s]", dir);
493: SitFor(7);
494: return 1;
495: }
496: if (nentries == 0) {
497: add_mess(" [No match]");
498: SitFor(7);
499: } else if (c == ' ' || c == '\t')
500: fill_in(dir_vec, nentries);
501: else {
502: /* we're a '?' */
503: int maxlen = 0,
504: ncols,
505: col,
506: lines,
507: linespercol;
508:
509: TOstart("Completion", FALSE); /* false means newline only on request */
510: Typeout("(! means file will not be chosen unless typed explicitly)");
511: Typeout((char *) 0);
512: Typeout("Possible completions (in %s):", dir);
513: Typeout((char *) 0);
514:
515: for (i = 0; i < nentries; i++)
516: maxlen = max(strlen(dir_vec[i]), maxlen);
517: maxlen += 4; /* pad each column with at least 4 spaces */
518: ncols = (CO - 2) / maxlen;
519: linespercol = 1 + (nentries / ncols);
520:
521: for (lines = 0; lines < linespercol; lines++) {
522: for (col = 0; col < ncols; col++) {
523: int isbad,
524: which;
525:
526: which = (col * linespercol) + lines;
527: if (which >= nentries)
528: break;
529: if (DispBadFs == YES)
530: isbad = bad_extension(dir_vec[which]);
531: else
532: isbad = NO;
533: Typeout("%s%-*s", isbad ? "!" : NullStr,
534: maxlen - isbad, dir_vec[which]);
535: }
536: Typeout((char *) 0);
537: }
538: TOstop();
539: }
540: freedir(&dir_vec, nentries);
541: return 1;
542: }
543:
544: #endif
545:
546: char *
547: ask_file(prmt, def, buf)
548: char *prmt,
549: *def,
550: *buf;
551: {
552: char *ans,
553: prompt[128],
554: *pretty_name = pr_name(def, YES);
555: if (prmt)
556: sprintf(prompt, prmt);
557: else {
558: if (def != 0 && *def != '\0')
559: sprintf(prompt, ": %f (default %s) ", pretty_name);
560: else
561: sprintf(prompt, ProcFmt);
562: }
563: #ifdef F_COMPLETION
564: ans = real_ask("\r\n \t?", f_complete, pretty_name, prompt);
565: if (ans == 0 && (ans = pretty_name) == 0)
566: complain("[No default file name]");
567: #else
568: ans = ask(pretty_name, prompt);
569: #endif
570: PathParse(ans, buf);
571:
572: return buf;
573: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.