xref: /freebsd/contrib/less/edit.c (revision 2be1a816b9ff69588e55be0a84cbe2a31efc0f2f)
1 /*
2  * Copyright (C) 1984-2007  Mark Nudelman
3  *
4  * You may distribute under the terms of either the GNU General Public
5  * License or the Less License, as specified in the README file.
6  *
7  * For more information about less, or for information on how to
8  * contact the author, see the README file.
9  */
10 
11 
12 #include "less.h"
13 #if HAVE_STAT
14 #include <sys/stat.h>
15 #endif
16 
17 public int fd0 = 0;
18 
19 extern int new_file;
20 extern int errmsgs;
21 extern int cbufs;
22 extern char *every_first_cmd;
23 extern int any_display;
24 extern int force_open;
25 extern int is_tty;
26 extern int sigs;
27 extern IFILE curr_ifile;
28 extern IFILE old_ifile;
29 extern struct scrpos initial_scrpos;
30 extern void constant *ml_examine;
31 #if SPACES_IN_FILENAMES
32 extern char openquote;
33 extern char closequote;
34 #endif
35 
36 #if LOGFILE
37 extern int logfile;
38 extern int force_logfile;
39 extern char *namelogfile;
40 #endif
41 
42 #if HAVE_STAT_INO
43 public dev_t curr_dev;
44 public ino_t curr_ino;
45 #endif
46 
47 char *curr_altfilename = NULL;
48 static void *curr_altpipe;
49 
50 
51 /*
52  * Textlist functions deal with a list of words separated by spaces.
53  * init_textlist sets up a textlist structure.
54  * forw_textlist uses that structure to iterate thru the list of
55  * words, returning each one as a standard null-terminated string.
56  * back_textlist does the same, but runs thru the list backwards.
57  */
58 	public void
59 init_textlist(tlist, str)
60 	struct textlist *tlist;
61 	char *str;
62 {
63 	char *s;
64 #if SPACES_IN_FILENAMES
65 	int meta_quoted = 0;
66 	int delim_quoted = 0;
67 	char *esc = get_meta_escape();
68 	int esclen = strlen(esc);
69 #endif
70 
71 	tlist->string = skipsp(str);
72 	tlist->endstring = tlist->string + strlen(tlist->string);
73 	for (s = str;  s < tlist->endstring;  s++)
74 	{
75 #if SPACES_IN_FILENAMES
76 		if (meta_quoted)
77 		{
78 			meta_quoted = 0;
79 		} else if (esclen > 0 && s + esclen < tlist->endstring &&
80 		           strncmp(s, esc, esclen) == 0)
81 		{
82 			meta_quoted = 1;
83 			s += esclen - 1;
84 		} else if (delim_quoted)
85 		{
86 			if (*s == closequote)
87 				delim_quoted = 0;
88 		} else /* (!delim_quoted) */
89 		{
90 			if (*s == openquote)
91 				delim_quoted = 1;
92 			else if (*s == ' ')
93 				*s = '\0';
94 		}
95 #else
96 		if (*s == ' ')
97 			*s = '\0';
98 #endif
99 	}
100 }
101 
102 	public char *
103 forw_textlist(tlist, prev)
104 	struct textlist *tlist;
105 	char *prev;
106 {
107 	char *s;
108 
109 	/*
110 	 * prev == NULL means return the first word in the list.
111 	 * Otherwise, return the word after "prev".
112 	 */
113 	if (prev == NULL)
114 		s = tlist->string;
115 	else
116 		s = prev + strlen(prev);
117 	if (s >= tlist->endstring)
118 		return (NULL);
119 	while (*s == '\0')
120 		s++;
121 	if (s >= tlist->endstring)
122 		return (NULL);
123 	return (s);
124 }
125 
126 	public char *
127 back_textlist(tlist, prev)
128 	struct textlist *tlist;
129 	char *prev;
130 {
131 	char *s;
132 
133 	/*
134 	 * prev == NULL means return the last word in the list.
135 	 * Otherwise, return the word before "prev".
136 	 */
137 	if (prev == NULL)
138 		s = tlist->endstring;
139 	else if (prev <= tlist->string)
140 		return (NULL);
141 	else
142 		s = prev - 1;
143 	while (*s == '\0')
144 		s--;
145 	if (s <= tlist->string)
146 		return (NULL);
147 	while (s[-1] != '\0' && s > tlist->string)
148 		s--;
149 	return (s);
150 }
151 
152 /*
153  * Close the current input file.
154  */
155 	static void
156 close_file()
157 {
158 	struct scrpos scrpos;
159 
160 	if (curr_ifile == NULL_IFILE)
161 		return;
162 
163 	/*
164 	 * Save the current position so that we can return to
165 	 * the same position if we edit this file again.
166 	 */
167 	get_scrpos(&scrpos);
168 	if (scrpos.pos != NULL_POSITION)
169 	{
170 		store_pos(curr_ifile, &scrpos);
171 		lastmark();
172 	}
173 	/*
174 	 * Close the file descriptor, unless it is a pipe.
175 	 */
176 	ch_close();
177 	/*
178 	 * If we opened a file using an alternate name,
179 	 * do special stuff to close it.
180 	 */
181 	if (curr_altfilename != NULL)
182 	{
183 		close_altfile(curr_altfilename, get_filename(curr_ifile),
184 				curr_altpipe);
185 		free(curr_altfilename);
186 		curr_altfilename = NULL;
187 	}
188 	curr_ifile = NULL_IFILE;
189 #if HAVE_STAT_INO
190 	curr_ino = curr_dev = 0;
191 #endif
192 }
193 
194 /*
195  * Edit a new file (given its name).
196  * Filename == "-" means standard input.
197  * Filename == NULL means just close the current file.
198  */
199 	public int
200 edit(filename)
201 	char *filename;
202 {
203 	if (filename == NULL)
204 		return (edit_ifile(NULL_IFILE));
205 	return (edit_ifile(get_ifile(filename, curr_ifile)));
206 }
207 
208 /*
209  * Edit a new file (given its IFILE).
210  * ifile == NULL means just close the current file.
211  */
212 	public int
213 edit_ifile(ifile)
214 	IFILE ifile;
215 {
216 	int f;
217 	int answer;
218 	int no_display;
219 	int chflags;
220 	char *filename;
221 	char *open_filename;
222 	char *qopen_filename;
223 	char *alt_filename;
224 	void *alt_pipe;
225 	IFILE was_curr_ifile;
226 	PARG parg;
227 
228 	if (ifile == curr_ifile)
229 	{
230 		/*
231 		 * Already have the correct file open.
232 		 */
233 		return (0);
234 	}
235 
236 	/*
237 	 * We must close the currently open file now.
238 	 * This is necessary to make the open_altfile/close_altfile pairs
239 	 * nest properly (or rather to avoid nesting at all).
240 	 * {{ Some stupid implementations of popen() mess up if you do:
241 	 *    fA = popen("A"); fB = popen("B"); pclose(fA); pclose(fB); }}
242 	 */
243 #if LOGFILE
244 	end_logfile();
245 #endif
246 	was_curr_ifile = save_curr_ifile();
247 	if (curr_ifile != NULL_IFILE)
248 	{
249 		chflags = ch_getflags();
250 		close_file();
251 		if ((chflags & CH_HELPFILE) && held_ifile(was_curr_ifile) <= 1)
252 		{
253 			/*
254 			 * Don't keep the help file in the ifile list.
255 			 */
256 			del_ifile(was_curr_ifile);
257 			was_curr_ifile = old_ifile;
258 		}
259 	}
260 
261 	if (ifile == NULL_IFILE)
262 	{
263 		/*
264 		 * No new file to open.
265 		 * (Don't set old_ifile, because if you call edit_ifile(NULL),
266 		 *  you're supposed to have saved curr_ifile yourself,
267 		 *  and you'll restore it if necessary.)
268 		 */
269 		unsave_ifile(was_curr_ifile);
270 		return (0);
271 	}
272 
273 	filename = save(get_filename(ifile));
274 	/*
275 	 * See if LESSOPEN specifies an "alternate" file to open.
276 	 */
277 	alt_pipe = NULL;
278 	alt_filename = open_altfile(filename, &f, &alt_pipe);
279 	open_filename = (alt_filename != NULL) ? alt_filename : filename;
280 	qopen_filename = shell_unquote(open_filename);
281 
282 	chflags = 0;
283 	if (alt_pipe != NULL)
284 	{
285 		/*
286 		 * The alternate "file" is actually a pipe.
287 		 * f has already been set to the file descriptor of the pipe
288 		 * in the call to open_altfile above.
289 		 * Keep the file descriptor open because it was opened
290 		 * via popen(), and pclose() wants to close it.
291 		 */
292 		chflags |= CH_POPENED;
293 	} else if (strcmp(open_filename, "-") == 0)
294 	{
295 		/*
296 		 * Use standard input.
297 		 * Keep the file descriptor open because we can't reopen it.
298 		 */
299 		f = fd0;
300 		chflags |= CH_KEEPOPEN;
301 		/*
302 		 * Must switch stdin to BINARY mode.
303 		 */
304 		SET_BINARY(f);
305 #if MSDOS_COMPILER==DJGPPC
306 		/*
307 		 * Setting stdin to binary by default causes
308 		 * Ctrl-C to not raise SIGINT.  We must undo
309 		 * that side-effect.
310 		 */
311 		__djgpp_set_ctrl_c(1);
312 #endif
313 	} else if (strcmp(open_filename, FAKE_HELPFILE) == 0)
314 	{
315 		f = -1;
316 		chflags |= CH_HELPFILE;
317 	} else if ((parg.p_string = bad_file(open_filename)) != NULL)
318 	{
319 		/*
320 		 * It looks like a bad file.  Don't try to open it.
321 		 */
322 		error("%s", &parg);
323 		free(parg.p_string);
324 	    err1:
325 		if (alt_filename != NULL)
326 		{
327 			close_altfile(alt_filename, filename, alt_pipe);
328 			free(alt_filename);
329 		}
330 		del_ifile(ifile);
331 		free(qopen_filename);
332 		free(filename);
333 		/*
334 		 * Re-open the current file.
335 		 */
336 		if (was_curr_ifile == ifile)
337 		{
338 			/*
339 			 * Whoops.  The "current" ifile is the one we just deleted.
340 			 * Just give up.
341 			 */
342 			quit(QUIT_ERROR);
343 		}
344 		reedit_ifile(was_curr_ifile);
345 		return (1);
346 	} else if ((f = open(qopen_filename, OPEN_READ)) < 0)
347 	{
348 		/*
349 		 * Got an error trying to open it.
350 		 */
351 		parg.p_string = errno_message(filename);
352 		error("%s", &parg);
353 		free(parg.p_string);
354 	    	goto err1;
355 	} else
356 	{
357 		chflags |= CH_CANSEEK;
358 		if (!force_open && !opened(ifile) && bin_file(f))
359 		{
360 			/*
361 			 * Looks like a binary file.
362 			 * Ask user if we should proceed.
363 			 */
364 			parg.p_string = filename;
365 			answer = query("\"%s\" may be a binary file.  See it anyway? ",
366 				&parg);
367 			if (answer != 'y' && answer != 'Y')
368 			{
369 				close(f);
370 				goto err1;
371 			}
372 		}
373 	}
374 
375 	/*
376 	 * Get the new ifile.
377 	 * Get the saved position for the file.
378 	 */
379 	if (was_curr_ifile != NULL_IFILE)
380 	{
381 		old_ifile = was_curr_ifile;
382 		unsave_ifile(was_curr_ifile);
383 	}
384 	curr_ifile = ifile;
385 	curr_altfilename = alt_filename;
386 	curr_altpipe = alt_pipe;
387 	set_open(curr_ifile); /* File has been opened */
388 	get_pos(curr_ifile, &initial_scrpos);
389 	new_file = TRUE;
390 	ch_init(f, chflags);
391 
392 	if (!(chflags & CH_HELPFILE))
393 	{
394 #if LOGFILE
395 		if (namelogfile != NULL && is_tty)
396 			use_logfile(namelogfile);
397 #endif
398 #if HAVE_STAT_INO
399 		/* Remember the i-number and device of the opened file. */
400 		{
401 			struct stat statbuf;
402 			int r = stat(qopen_filename, &statbuf);
403 			if (r == 0)
404 			{
405 				curr_ino = statbuf.st_ino;
406 				curr_dev = statbuf.st_dev;
407 			}
408 		}
409 #endif
410 		if (every_first_cmd != NULL)
411 			ungetsc(every_first_cmd);
412 	}
413 
414 	free(qopen_filename);
415 	no_display = !any_display;
416 	flush();
417 	any_display = TRUE;
418 
419 	if (is_tty)
420 	{
421 		/*
422 		 * Output is to a real tty.
423 		 */
424 
425 		/*
426 		 * Indicate there is nothing displayed yet.
427 		 */
428 		pos_clear();
429 		clr_linenum();
430 #if HILITE_SEARCH
431 		clr_hilite();
432 #endif
433 		cmd_addhist(ml_examine, filename);
434 		if (no_display && errmsgs > 0)
435 		{
436 			/*
437 			 * We displayed some messages on error output
438 			 * (file descriptor 2; see error() function).
439 			 * Before erasing the screen contents,
440 			 * display the file name and wait for a keystroke.
441 			 */
442 			parg.p_string = filename;
443 			error("%s", &parg);
444 		}
445 	}
446 	free(filename);
447 	return (0);
448 }
449 
450 /*
451  * Edit a space-separated list of files.
452  * For each filename in the list, enter it into the ifile list.
453  * Then edit the first one.
454  */
455 	public int
456 edit_list(filelist)
457 	char *filelist;
458 {
459 	IFILE save_ifile;
460 	char *good_filename;
461 	char *filename;
462 	char *gfilelist;
463 	char *gfilename;
464 	struct textlist tl_files;
465 	struct textlist tl_gfiles;
466 
467 	save_ifile = save_curr_ifile();
468 	good_filename = NULL;
469 
470 	/*
471 	 * Run thru each filename in the list.
472 	 * Try to glob the filename.
473 	 * If it doesn't expand, just try to open the filename.
474 	 * If it does expand, try to open each name in that list.
475 	 */
476 	init_textlist(&tl_files, filelist);
477 	filename = NULL;
478 	while ((filename = forw_textlist(&tl_files, filename)) != NULL)
479 	{
480 		gfilelist = lglob(filename);
481 		init_textlist(&tl_gfiles, gfilelist);
482 		gfilename = NULL;
483 		while ((gfilename = forw_textlist(&tl_gfiles, gfilename)) != NULL)
484 		{
485 			if (edit(gfilename) == 0 && good_filename == NULL)
486 				good_filename = get_filename(curr_ifile);
487 		}
488 		free(gfilelist);
489 	}
490 	/*
491 	 * Edit the first valid filename in the list.
492 	 */
493 	if (good_filename == NULL)
494 	{
495 		unsave_ifile(save_ifile);
496 		return (1);
497 	}
498 	if (get_ifile(good_filename, curr_ifile) == curr_ifile)
499 	{
500 		/*
501 		 * Trying to edit the current file; don't reopen it.
502 		 */
503 		unsave_ifile(save_ifile);
504 		return (0);
505 	}
506 	reedit_ifile(save_ifile);
507 	return (edit(good_filename));
508 }
509 
510 /*
511  * Edit the first file in the command line (ifile) list.
512  */
513 	public int
514 edit_first()
515 {
516 	curr_ifile = NULL_IFILE;
517 	return (edit_next(1));
518 }
519 
520 /*
521  * Edit the last file in the command line (ifile) list.
522  */
523 	public int
524 edit_last()
525 {
526 	curr_ifile = NULL_IFILE;
527 	return (edit_prev(1));
528 }
529 
530 
531 /*
532  * Edit the n-th next or previous file in the command line (ifile) list.
533  */
534 	static int
535 edit_istep(h, n, dir)
536 	IFILE h;
537 	int n;
538 	int dir;
539 {
540 	IFILE next;
541 
542 	/*
543 	 * Skip n filenames, then try to edit each filename.
544 	 */
545 	for (;;)
546 	{
547 		next = (dir > 0) ? next_ifile(h) : prev_ifile(h);
548 		if (--n < 0)
549 		{
550 			if (edit_ifile(h) == 0)
551 				break;
552 		}
553 		if (next == NULL_IFILE)
554 		{
555 			/*
556 			 * Reached end of the ifile list.
557 			 */
558 			return (1);
559 		}
560 		if (ABORT_SIGS())
561 		{
562 			/*
563 			 * Interrupt breaks out, if we're in a long
564 			 * list of files that can't be opened.
565 			 */
566 			return (1);
567 		}
568 		h = next;
569 	}
570 	/*
571 	 * Found a file that we can edit.
572 	 */
573 	return (0);
574 }
575 
576 	static int
577 edit_inext(h, n)
578 	IFILE h;
579 	int n;
580 {
581 	return (edit_istep(h, n, +1));
582 }
583 
584 	public int
585 edit_next(n)
586 	int n;
587 {
588 	return edit_istep(curr_ifile, n, +1);
589 }
590 
591 	static int
592 edit_iprev(h, n)
593 	IFILE h;
594 	int n;
595 {
596 	return (edit_istep(h, n, -1));
597 }
598 
599 	public int
600 edit_prev(n)
601 	int n;
602 {
603 	return edit_istep(curr_ifile, n, -1);
604 }
605 
606 /*
607  * Edit a specific file in the command line (ifile) list.
608  */
609 	public int
610 edit_index(n)
611 	int n;
612 {
613 	IFILE h;
614 
615 	h = NULL_IFILE;
616 	do
617 	{
618 		if ((h = next_ifile(h)) == NULL_IFILE)
619 		{
620 			/*
621 			 * Reached end of the list without finding it.
622 			 */
623 			return (1);
624 		}
625 	} while (get_index(h) != n);
626 
627 	return (edit_ifile(h));
628 }
629 
630 	public IFILE
631 save_curr_ifile()
632 {
633 	if (curr_ifile != NULL_IFILE)
634 		hold_ifile(curr_ifile, 1);
635 	return (curr_ifile);
636 }
637 
638 	public void
639 unsave_ifile(save_ifile)
640 	IFILE save_ifile;
641 {
642 	if (save_ifile != NULL_IFILE)
643 		hold_ifile(save_ifile, -1);
644 }
645 
646 /*
647  * Reedit the ifile which was previously open.
648  */
649 	public void
650 reedit_ifile(save_ifile)
651 	IFILE save_ifile;
652 {
653 	IFILE next;
654 	IFILE prev;
655 
656 	/*
657 	 * Try to reopen the ifile.
658 	 * Note that opening it may fail (maybe the file was removed),
659 	 * in which case the ifile will be deleted from the list.
660 	 * So save the next and prev ifiles first.
661 	 */
662 	unsave_ifile(save_ifile);
663 	next = next_ifile(save_ifile);
664 	prev = prev_ifile(save_ifile);
665 	if (edit_ifile(save_ifile) == 0)
666 		return;
667 	/*
668 	 * If can't reopen it, open the next input file in the list.
669 	 */
670 	if (next != NULL_IFILE && edit_inext(next, 0) == 0)
671 		return;
672 	/*
673 	 * If can't open THAT one, open the previous input file in the list.
674 	 */
675 	if (prev != NULL_IFILE && edit_iprev(prev, 0) == 0)
676 		return;
677 	/*
678 	 * If can't even open that, we're stuck.  Just quit.
679 	 */
680 	quit(QUIT_ERROR);
681 }
682 
683 	public void
684 reopen_curr_ifile()
685 {
686 	IFILE save_ifile = save_curr_ifile();
687 	close_file();
688 	reedit_ifile(save_ifile);
689 }
690 
691 /*
692  * Edit standard input.
693  */
694 	public int
695 edit_stdin()
696 {
697 	if (isatty(fd0))
698 	{
699 		error("Missing filename (\"less --help\" for help)", NULL_PARG);
700 		quit(QUIT_OK);
701 	}
702 	return (edit("-"));
703 }
704 
705 /*
706  * Copy a file directly to standard output.
707  * Used if standard output is not a tty.
708  */
709 	public void
710 cat_file()
711 {
712 	register int c;
713 
714 	while ((c = ch_forw_get()) != EOI)
715 		putchr(c);
716 	flush();
717 }
718 
719 #if LOGFILE
720 
721 /*
722  * If the user asked for a log file and our input file
723  * is standard input, create the log file.
724  * We take care not to blindly overwrite an existing file.
725  */
726 	public void
727 use_logfile(filename)
728 	char *filename;
729 {
730 	register int exists;
731 	register int answer;
732 	PARG parg;
733 
734 	if (ch_getflags() & CH_CANSEEK)
735 		/*
736 		 * Can't currently use a log file on a file that can seek.
737 		 */
738 		return;
739 
740 	/*
741 	 * {{ We could use access() here. }}
742 	 */
743 	filename = shell_unquote(filename);
744 	exists = open(filename, OPEN_READ);
745 	close(exists);
746 	exists = (exists >= 0);
747 
748 	/*
749 	 * Decide whether to overwrite the log file or append to it.
750 	 * If it doesn't exist we "overwrite" it.
751 	 */
752 	if (!exists || force_logfile)
753 	{
754 		/*
755 		 * Overwrite (or create) the log file.
756 		 */
757 		answer = 'O';
758 	} else
759 	{
760 		/*
761 		 * Ask user what to do.
762 		 */
763 		parg.p_string = filename;
764 		answer = query("Warning: \"%s\" exists; Overwrite, Append or Don't log? ", &parg);
765 	}
766 
767 loop:
768 	switch (answer)
769 	{
770 	case 'O': case 'o':
771 		/*
772 		 * Overwrite: create the file.
773 		 */
774 		logfile = creat(filename, 0644);
775 		break;
776 	case 'A': case 'a':
777 		/*
778 		 * Append: open the file and seek to the end.
779 		 */
780 		logfile = open(filename, OPEN_APPEND);
781 		if (lseek(logfile, (off_t)0, SEEK_END) == BAD_LSEEK)
782 		{
783 			close(logfile);
784 			logfile = -1;
785 		}
786 		break;
787 	case 'D': case 'd':
788 		/*
789 		 * Don't do anything.
790 		 */
791 		free(filename);
792 		return;
793 	case 'q':
794 		quit(QUIT_OK);
795 		/*NOTREACHED*/
796 	default:
797 		/*
798 		 * Eh?
799 		 */
800 		answer = query("Overwrite, Append, or Don't log? (Type \"O\", \"A\", \"D\" or \"q\") ", NULL_PARG);
801 		goto loop;
802 	}
803 
804 	if (logfile < 0)
805 	{
806 		/*
807 		 * Error in opening logfile.
808 		 */
809 		parg.p_string = filename;
810 		error("Cannot write to \"%s\"", &parg);
811 		free(filename);
812 		return;
813 	}
814 	free(filename);
815 	SET_BINARY(logfile);
816 }
817 
818 #endif
819