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