xref: /minix/bin/csh/file.c (revision d1e4d7ce)
1 /* $NetBSD: file.c,v 1.30 2013/07/16 17:47:43 christos Exp $ */
2 
3 /*-
4  * Copyright (c) 1980, 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #include <sys/cdefs.h>
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)file.c	8.2 (Berkeley) 3/19/94";
36 #else
37 __RCSID("$NetBSD: file.c,v 1.30 2013/07/16 17:47:43 christos Exp $");
38 #endif
39 #endif /* not lint */
40 
41 #ifdef FILEC
42 
43 #include <sys/ioctl.h>
44 #include <sys/param.h>
45 #include <sys/stat.h>
46 #include <sys/tty.h>
47 
48 #include <dirent.h>
49 #include <pwd.h>
50 #include <termios.h>
51 #include <stdarg.h>
52 #include <stdlib.h>
53 #include <unistd.h>
54 
55 #ifndef SHORT_STRINGS
56 #include <string.h>
57 #endif /* SHORT_STRINGS */
58 
59 #include "csh.h"
60 #include "extern.h"
61 
62 /*
63  * Tenex style file name recognition, .. and more.
64  * History:
65  *	Author: Ken Greer, Sept. 1975, CMU.
66  *	Finally got around to adding to the Cshell., Ken Greer, Dec. 1981.
67  */
68 
69 #define ON	1
70 #define OFF	0
71 #ifndef TRUE
72 #define TRUE 1
73 #endif
74 #ifndef FALSE
75 #define FALSE 0
76 #endif
77 
78 #define ESC '\033'
79 
80 typedef enum {
81     LIST, RECOGNIZE
82 }       COMMAND;
83 
84 static void setup_tty(int);
85 static void back_to_col_1(void);
86 static int pushback(Char *);
87 static void catn(Char *, Char *, size_t);
88 static void copyn(Char *, Char *, size_t);
89 static Char filetype(Char *, Char *);
90 static void print_by_column(Char *, Char *[], size_t);
91 static Char *tilde(Char *, Char *);
92 static void retype(void);
93 static void beep(void);
94 static void print_recognized_stuff(Char *);
95 static void extract_dir_and_name(Char *, Char *, Char *);
96 static Char *getentry(DIR *, int);
97 static void free_items(Char **, size_t);
98 static size_t tsearch(Char *, COMMAND, size_t);
99 static int recognize(Char *, Char *, size_t, size_t);
100 static int is_prefix(Char *, Char *);
101 static int is_suffix(Char *, Char *);
102 static int ignored(Char *);
103 
104 /*
105  * Put this here so the binary can be patched with adb to enable file
106  * completion by default.  Filec controls completion, nobeep controls
107  * ringing the terminal bell on incomplete expansions.
108  */
109 int filec = 0;
110 
111 static void
setup_tty(int on)112 setup_tty(int on)
113 {
114     struct termios tchars;
115 
116     (void)tcgetattr(SHIN, &tchars);
117 
118     if (on) {
119 	tchars.c_cc[VEOL] = ESC;
120 	if (tchars.c_lflag & ICANON)
121 	    on = TCSADRAIN;
122 	else {
123 	    tchars.c_lflag |= ICANON;
124 	    on = TCSAFLUSH;
125 	}
126     }
127     else {
128 	tchars.c_cc[VEOL] = _POSIX_VDISABLE;
129 	on = TCSADRAIN;
130     }
131 
132     (void)tcsetattr(SHIN, on, &tchars);
133 }
134 
135 /*
136  * Move back to beginning of current line
137  */
138 static void
back_to_col_1(void)139 back_to_col_1(void)
140 {
141     struct termios tty, tty_normal;
142     sigset_t nsigset, osigset;
143 
144     sigemptyset(&nsigset);
145     (void)sigaddset(&nsigset, SIGINT);
146     (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
147     (void)tcgetattr(SHOUT, &tty);
148     tty_normal = tty;
149     tty.c_iflag &= ~INLCR;
150     tty.c_oflag &= ~ONLCR;
151     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
152     (void)write(SHOUT, "\r", 1);
153     (void)tcsetattr(SHOUT, TCSADRAIN, &tty_normal);
154     (void)sigprocmask(SIG_SETMASK, &osigset, NULL);
155 }
156 
157 /*
158  * Push string contents back into tty queue
159  */
160 static int
pushback(Char * string)161 pushback(Char *string)
162 {
163     struct termios tty, tty_normal;
164     char buf[64], svchars[sizeof(buf)];
165     sigset_t nsigset, osigset;
166     Char *p;
167     size_t bufidx, i, len_str, nbuf, nsv, onsv, retrycnt;
168     char c;
169 
170     nsv = 0;
171     sigemptyset(&nsigset);
172     (void)sigaddset(&nsigset, SIGINT);
173     (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
174     (void)tcgetattr(SHOUT, &tty);
175     tty_normal = tty;
176     tty.c_lflag &= ~(ECHOKE | ECHO | ECHOE | ECHOK | ECHONL | ECHOPRT | ECHOCTL);
177     /* FIONREAD works only in noncanonical mode. */
178     tty.c_lflag &= ~ICANON;
179     tty.c_cc[VMIN] = 0;
180     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
181 
182     for (retrycnt = 5; ; retrycnt--) {
183 	/*
184 	 * Push back characters.
185 	 */
186 	for (p = string; (c = (char)*p) != '\0'; p++)
187 	    (void)ioctl(SHOUT, TIOCSTI, (ioctl_t) &c);
188 	for (i = 0; i < nsv; i++)
189 	    (void)ioctl(SHOUT, TIOCSTI, (ioctl_t) &svchars[i]);
190 
191 	if (retrycnt == 0)
192 	    break;		/* give up salvaging characters */
193 
194 	len_str = (size_t)(p - string);
195 
196 	if (ioctl(SHOUT, FIONREAD, (ioctl_t) &nbuf) ||
197 	    nbuf <= len_str + nsv ||	/* The string fit. */
198 	    nbuf > sizeof(buf))		/* For future binary compatibility
199 					   (and safety). */
200 	    break;
201 
202 	/*
203 	 * User has typed characters before the pushback finished.
204 	 * Salvage the characters.
205 	 */
206 
207 	/* This read() should be in noncanonical mode. */
208 	if (read(SHOUT, &buf, nbuf) != (ssize_t)nbuf)
209 	    continue;		/* hangup? */
210 
211 	onsv = nsv;
212 	for (bufidx = 0, i = 0; bufidx < nbuf; bufidx++, i++) {
213 	    c = buf[bufidx];
214 	    if ((i < len_str) ? c != (char)string[i] :
215 			(i < len_str + onsv) ? c != svchars[i - len_str] : 1) {
216 		/* Salvage a character. */
217 		if (nsv < (int)(sizeof svchars / sizeof svchars[0])) {
218 		    svchars[nsv++] = c;
219 		    i--;	/* try this comparison with the next char */
220 		} else
221 		    break;	/* too many */
222 	    }
223 	}
224     }
225 
226 #if 1
227     /*
228      * XXX  Is this a bug or a feature of kernel tty driver?
229      *
230      * FIONREAD in canonical mode does not return correct byte count
231      * in tty input queue, but this is required to avoid unwanted echo.
232      */
233     tty.c_lflag |= ICANON;
234     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
235     (void)ioctl(SHOUT, FIONREAD, (ioctl_t) &i);
236 #endif
237     (void)tcsetattr(SHOUT, TCSADRAIN, &tty_normal);
238     (void)sigprocmask(SIG_SETMASK, &osigset, NULL);
239 
240     return (int)nsv;
241 }
242 
243 /*
244  * Concatenate src onto tail of des.
245  * Des is a string whose maximum length is count.
246  * Always null terminate.
247  */
248 static void
catn(Char * des,Char * src,size_t count)249 catn(Char *des, Char *src, size_t count)
250 {
251     while (count-- > 0 && *des)
252 	des++;
253     while (count-- > 0)
254 	if ((*des++ = *src++) == 0)
255 	    return;
256     *des = '\0';
257 }
258 
259 /*
260  * Like strncpy but always leave room for trailing \0
261  * and always null terminate.
262  */
263 static void
copyn(Char * des,Char * src,size_t count)264 copyn(Char *des, Char *src, size_t count)
265 {
266     while (count-- > 0)
267 	if ((*des++ = *src++) == 0)
268 	    return;
269     *des = '\0';
270 }
271 
272 static Char
filetype(Char * dir,Char * file)273 filetype(Char *dir, Char *file)
274 {
275     struct stat statb;
276     Char path[MAXPATHLEN];
277 
278     catn(Strcpy(path, dir), file, sizeof(path) / sizeof(Char));
279     if (lstat(short2str(path), &statb) == 0) {
280 	switch (statb.st_mode & S_IFMT) {
281 	case S_IFDIR:
282 	    return ('/');
283 	case S_IFLNK:
284 	    if (stat(short2str(path), &statb) == 0 &&	/* follow it out */
285 		S_ISDIR(statb.st_mode))
286 		return ('>');
287 	    else
288 		return ('@');
289 	case S_IFSOCK:
290 	    return ('=');
291 	default:
292 	    if (statb.st_mode & 0111)
293 		return ('*');
294 	}
295     }
296     return (' ');
297 }
298 
299 static struct winsize win;
300 
301 /*
302  * Print sorted down columns
303  */
304 static void
print_by_column(Char * dir,Char * items[],size_t count)305 print_by_column(Char *dir, Char *items[], size_t count)
306 {
307     size_t c, columns, i, maxwidth, r, rows;
308 
309     maxwidth = 0;
310 
311     if (ioctl(SHOUT, TIOCGWINSZ, (ioctl_t) & win) < 0 || win.ws_col == 0)
312 	win.ws_col = 80;
313     for (i = 0; i < count; i++)
314 	maxwidth = maxwidth > (r = Strlen(items[i])) ? maxwidth : r;
315     maxwidth += 2;		/* for the file tag and space */
316     columns = win.ws_col / maxwidth;
317     if (columns == 0)
318 	columns = 1;
319     rows = (count + (columns - 1)) / columns;
320     for (r = 0; r < rows; r++) {
321 	for (c = 0; c < columns; c++) {
322 	    i = c * rows + r;
323 	    if (i < count) {
324 		size_t w;
325 
326 		(void)fprintf(cshout, "%s", vis_str(items[i]));
327 		(void)fputc(dir ? filetype(dir, items[i]) : ' ', cshout);
328 		if (c < columns - 1) {	/* last column? */
329 		    w = Strlen(items[i]) + 1;
330 		    for (; w < maxwidth; w++)
331 			(void) fputc(' ', cshout);
332 		}
333 	    }
334 	}
335 	(void)fputc('\r', cshout);
336 	(void)fputc('\n', cshout);
337     }
338 }
339 
340 /*
341  * Expand file name with possible tilde usage
342  *	~person/mumble
343  * expands to
344  *	home_directory_of_person/mumble
345  */
346 static Char *
tilde(Char * new,Char * old)347 tilde(Char *new, Char *old)
348 {
349     static Char person[40];
350     struct passwd *pw;
351     Char *o, *p;
352 
353     if (old[0] != '~')
354 	return (Strcpy(new, old));
355 
356     for (p = person, o = &old[1]; *o && *o != '/'; *p++ = *o++)
357 	continue;
358     *p = '\0';
359     if (person[0] == '\0')
360 	(void)Strcpy(new, value(STRhome));
361     else {
362 	pw = getpwnam(short2str(person));
363 	if (pw == NULL)
364 	    return (NULL);
365 	(void)Strcpy(new, str2short(pw->pw_dir));
366     }
367     (void)Strcat(new, o);
368     return (new);
369 }
370 
371 /*
372  * Cause pending line to be printed
373  */
374 static void
retype(void)375 retype(void)
376 {
377     struct termios tty;
378 
379     (void)tcgetattr(SHOUT, &tty);
380     tty.c_lflag |= PENDIN;
381     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
382 }
383 
384 static void
beep(void)385 beep(void)
386 {
387     if (adrof(STRnobeep) == 0)
388 	(void)write(SHOUT, "\007", 1);
389 }
390 
391 /*
392  * Erase that silly ^[ and
393  * print the recognized part of the string
394  */
395 static void
print_recognized_stuff(Char * recognized_part)396 print_recognized_stuff(Char *recognized_part)
397 {
398     /* An optimized erasing of that silly ^[ */
399     (void)fputc('\b', cshout);
400     (void)fputc('\b', cshout);
401     switch (Strlen(recognized_part)) {
402     case 0:			/* erase two Characters: ^[ */
403 	(void)fputc(' ', cshout);
404 	(void)fputc(' ', cshout);
405 	(void)fputc('\b', cshout);
406 	(void)fputc('\b', cshout);
407 	break;
408     case 1:			/* overstrike the ^, erase the [ */
409 	(void)fprintf(cshout, "%s", vis_str(recognized_part));
410 	(void)fputc(' ', cshout);
411 	(void)fputc('\b', cshout);
412 	break;
413     default:			/* overstrike both Characters ^[ */
414 	(void)fprintf(cshout, "%s", vis_str(recognized_part));
415 	break;
416     }
417     (void)fflush(cshout);
418 }
419 
420 /*
421  * Parse full path in file into 2 parts: directory and file names
422  * Should leave final slash (/) at end of dir.
423  */
424 static void
extract_dir_and_name(Char * path,Char * dir,Char * name)425 extract_dir_and_name(Char *path, Char *dir, Char *name)
426 {
427     Char *p;
428 
429     p = Strrchr(path, '/');
430     if (p == NULL) {
431 	copyn(name, path, MAXNAMLEN);
432 	dir[0] = '\0';
433     }
434     else {
435 	copyn(name, ++p, MAXNAMLEN);
436 	copyn(dir, path, (size_t)(p - path));
437     }
438 }
439 
440 static Char *
getentry(DIR * dir_fd,int looking_for_lognames)441 getentry(DIR *dir_fd, int looking_for_lognames)
442 {
443     struct dirent *dirp;
444     struct passwd *pw;
445 
446     if (looking_for_lognames) {
447 	if ((pw = getpwent()) == NULL)
448 	    return (NULL);
449 	return (str2short(pw->pw_name));
450     }
451     if ((dirp = readdir(dir_fd)) != NULL)
452 	return (str2short(dirp->d_name));
453     return (NULL);
454 }
455 
456 static void
free_items(Char ** items,size_t numitems)457 free_items(Char **items, size_t numitems)
458 {
459     size_t i;
460 
461     for (i = 0; i < numitems; i++)
462 	xfree((ptr_t) items[i]);
463     xfree((ptr_t) items);
464 }
465 
466 #define FREE_ITEMS(items, numitems) { \
467 	sigset_t nsigset, osigset;\
468 \
469 	sigemptyset(&nsigset);\
470 	(void) sigaddset(&nsigset, SIGINT);\
471 	(void) sigprocmask(SIG_BLOCK, &nsigset, &osigset);\
472 	free_items(items, numitems);\
473 	(void) sigprocmask(SIG_SETMASK, &osigset, NULL);\
474 }
475 
476 /*
477  * Perform a RECOGNIZE or LIST command on string "word".
478  */
479 static size_t
tsearch(Char * word,COMMAND command,size_t max_word_length)480 tsearch(Char *word, COMMAND command, size_t max_word_length)
481 {
482     Char dir[MAXPATHLEN + 1], extended_name[MAXNAMLEN + 1];
483     Char name[MAXNAMLEN + 1], tilded_dir[MAXPATHLEN + 1];
484     DIR *dir_fd;
485     Char *entry;
486     int ignoring, looking_for_lognames;
487     size_t name_length, nignored, numitems;
488     Char **items = NULL;
489     size_t maxitems = 0;
490 
491     numitems = 0;
492     ignoring = TRUE;
493     nignored = 0;
494 
495     looking_for_lognames = (*word == '~') && (Strchr(word, '/') == NULL);
496     if (looking_for_lognames) {
497 	(void)setpwent();
498 	copyn(name, &word[1], MAXNAMLEN);	/* name sans ~ */
499 	dir_fd = NULL;
500     }
501     else {
502 	extract_dir_and_name(word, dir, name);
503 	if (tilde(tilded_dir, dir) == 0)
504 	    return (0);
505 	dir_fd = opendir(*tilded_dir ? short2str(tilded_dir) : ".");
506 	if (dir_fd == NULL)
507 	    return (0);
508     }
509 
510 again:				/* search for matches */
511     name_length = Strlen(name);
512     for (numitems = 0; (entry = getentry(dir_fd, looking_for_lognames)) != NULL;) {
513 	if (!is_prefix(name, entry))
514 	    continue;
515 	/* Don't match . files on null prefix match */
516 	if (name_length == 0 && entry[0] == '.' &&
517 	    !looking_for_lognames)
518 	    continue;
519 	if (command == LIST) {
520 	    if ((size_t)numitems >= maxitems) {
521 		maxitems += 1024;
522 		if (items == NULL)
523 			items = xmalloc(sizeof(*items) * maxitems);
524 		else
525 			items = xrealloc((ptr_t) items,
526 			    sizeof(*items) * maxitems);
527  	    }
528 	    items[numitems] = xmalloc((size_t) (Strlen(entry) + 1) *
529 	        sizeof(Char));
530 	    copyn(items[numitems], entry, MAXNAMLEN);
531 	    numitems++;
532 	}
533 	else {			/* RECOGNIZE command */
534 	    if (ignoring && ignored(entry))
535 		nignored++;
536 	    else if (recognize(extended_name,
537 	        entry, name_length, ++numitems))
538 		break;
539 	}
540     }
541     if (ignoring && numitems == 0 && nignored > 0) {
542 	ignoring = FALSE;
543 	nignored = 0;
544 	if (looking_for_lognames)
545 	    (void)setpwent();
546 	else
547 	    rewinddir(dir_fd);
548 	goto again;
549     }
550 
551     if (looking_for_lognames)
552 	(void)endpwent();
553     else
554 	(void)closedir(dir_fd);
555     if (numitems == 0)
556 	return (0);
557     if (command == RECOGNIZE) {
558 	if (looking_for_lognames)
559 	    copyn(word, STRtilde, 1);
560 	else
561 	    /* put back dir part */
562 	    copyn(word, dir, max_word_length);
563 	/* add extended name */
564 	catn(word, extended_name, max_word_length);
565 	return (numitems);
566     }
567     else {			/* LIST */
568 	qsort((ptr_t) items, numitems, sizeof(items[0]),
569 		(int (*) (const void *, const void *)) sortscmp);
570 	print_by_column(looking_for_lognames ? NULL : tilded_dir,
571 			items, numitems);
572 	if (items != NULL)
573 	    FREE_ITEMS(items, numitems);
574     }
575     return (0);
576 }
577 
578 /*
579  * Object: extend what user typed up to an ambiguity.
580  * Algorithm:
581  * On first match, copy full entry (assume it'll be the only match)
582  * On subsequent matches, shorten extended_name to the first
583  * Character mismatch between extended_name and entry.
584  * If we shorten it back to the prefix length, stop searching.
585  */
586 static int
recognize(Char * extended_name,Char * entry,size_t name_length,size_t numitems)587 recognize(Char *extended_name, Char *entry, size_t name_length, size_t numitems)
588 {
589     if (numitems == 1)		/* 1st match */
590 	copyn(extended_name, entry, MAXNAMLEN);
591     else {			/* 2nd & subsequent matches */
592 	Char *ent, *x;
593 	size_t len = 0;
594 
595 	x = extended_name;
596 	for (ent = entry; *x && *x == *ent++; x++, len++)
597 	    continue;
598 	*x = '\0';		/* Shorten at 1st Char diff */
599 	if (len == name_length)	/* Ambiguous to prefix? */
600 	    return (-1);	/* So stop now and save time */
601     }
602     return (0);
603 }
604 
605 /*
606  * Return true if check matches initial Chars in template.
607  * This differs from PWB imatch in that if check is null
608  * it matches anything.
609  */
610 static int
is_prefix(Char * check,Char * template)611 is_prefix(Char *check, Char *template)
612 {
613     do
614 	if (*check == 0)
615 	    return (TRUE);
616     while (*check++ == *template++);
617     return (FALSE);
618 }
619 
620 /*
621  *  Return true if the Chars in template appear at the
622  *  end of check, I.e., are its suffix.
623  */
624 static int
is_suffix(Char * check,Char * template)625 is_suffix(Char *check, Char *template)
626 {
627     Char *c, *t;
628 
629     for (c = check; *c++;)
630 	continue;
631     for (t = template; *t++;)
632 	continue;
633     for (;;) {
634 	if (t == template)
635 	    return 1;
636 	if (c == check || *--t != *--c)
637 	    return 0;
638     }
639 }
640 
641 ssize_t
tenex(Char * inputline,size_t inputline_size)642 tenex(Char *inputline, size_t inputline_size)
643 {
644     char tinputline[BUFSIZE];
645     ssize_t num_read;
646     size_t numitems;
647 
648     setup_tty(ON);
649 
650     while ((num_read = read(SHIN, tinputline, BUFSIZE)) > 0) {
651 	size_t i, nr = (size_t) num_read;
652 
653 
654 	static Char delims[] = {' ', '\'', '"', '\t', ';', '&', '<',
655 	'>', '(', ')', '|', '^', '%', '\0'};
656 	Char *str_end, *word_start, last_Char, should_retype;
657 	size_t space_left;
658 	COMMAND command;
659 
660 	for (i = 0; i < nr; i++)
661 	    inputline[i] = (unsigned char) tinputline[i];
662 	last_Char = inputline[nr - 1] & ASCII;
663 
664 	if (last_Char == '\n' || nr == inputline_size)
665 	    break;
666 	command = (last_Char == ESC) ? RECOGNIZE : LIST;
667 	if (command == LIST)
668 	    (void)fputc('\n', cshout);
669 	str_end = &inputline[nr];
670 	if (last_Char == ESC)
671 	    --str_end;		/* wipeout trailing cmd Char */
672 	*str_end = '\0';
673 	/*
674 	 * Find LAST occurence of a delimiter in the inputline. The word start
675 	 * is one Character past it.
676 	 */
677 	for (word_start = str_end; word_start > inputline; --word_start)
678 	    if (Strchr(delims, word_start[-1]))
679 		break;
680 	space_left = inputline_size - (size_t)(word_start - inputline) - 1;
681 	numitems = tsearch(word_start, command, space_left);
682 
683 	if (command == RECOGNIZE) {
684 	    /* print from str_end on */
685 	    print_recognized_stuff(str_end);
686 	    if (numitems != 1)	/* Beep = No match/ambiguous */
687 		beep();
688 	}
689 
690 	/*
691 	 * Tabs in the input line cause trouble after a pushback. tty driver
692 	 * won't backspace over them because column positions are now
693 	 * incorrect. This is solved by retyping over current line.
694 	 */
695 	should_retype = FALSE;
696 	if (Strchr(inputline, '\t')) {	/* tab Char in input line? */
697 	    back_to_col_1();
698 	    should_retype = TRUE;
699 	}
700 	if (command == LIST)	/* Always retype after a LIST */
701 	    should_retype = TRUE;
702 	if (pushback(inputline))
703 	    should_retype = TRUE;
704 	if (should_retype) {
705 	    if (command == RECOGNIZE)
706 		(void) fputc('\n', cshout);
707 	    printprompt();
708 	}
709 	if (should_retype)
710 	    retype();
711     }
712     setup_tty(OFF);
713     return num_read;
714 }
715 
716 static int
ignored(Char * entry)717 ignored(Char *entry)
718 {
719     struct varent *vp;
720     Char **cp;
721 
722     if ((vp = adrof(STRfignore)) == NULL || (cp = vp->vec) == NULL)
723 	return (FALSE);
724     for (; *cp != NULL; cp++)
725 	if (is_suffix(entry, *cp))
726 	    return (TRUE);
727     return (FALSE);
728 }
729 #endif				/* FILEC */
730