xref: /freebsd/contrib/less/output.c (revision e11b6fa307b49a2a9ba2d0af0d80ddc103c84c10)
1 /*
2  * Copyright (C) 1984-2012  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, see the README file.
8  */
9 
10 
11 /*
12  * High level routines dealing with the output to the screen.
13  */
14 
15 #include "less.h"
16 #if MSDOS_COMPILER==WIN32C
17 #include "windows.h"
18 #endif
19 
20 public int errmsgs;	/* Count of messages displayed by error() */
21 public int need_clr;
22 public int final_attr;
23 public int at_prompt;
24 
25 extern int sigs;
26 extern int sc_width;
27 extern int so_s_width, so_e_width;
28 extern int screen_trashed;
29 extern int any_display;
30 extern int is_tty;
31 extern int oldbot;
32 
33 #if MSDOS_COMPILER==WIN32C || MSDOS_COMPILER==BORLANDC || MSDOS_COMPILER==DJGPPC
34 extern int ctldisp;
35 extern int nm_fg_color, nm_bg_color;
36 extern int bo_fg_color, bo_bg_color;
37 extern int ul_fg_color, ul_bg_color;
38 extern int so_fg_color, so_bg_color;
39 extern int bl_fg_color, bl_bg_color;
40 #endif
41 
42 /*
43  * Display the line which is in the line buffer.
44  */
45 	public void
46 put_line()
47 {
48 	register int c;
49 	register int i;
50 	int a;
51 
52 	if (ABORT_SIGS())
53 	{
54 		/*
55 		 * Don't output if a signal is pending.
56 		 */
57 		screen_trashed = 1;
58 		return;
59 	}
60 
61 	final_attr = AT_NORMAL;
62 
63 	for (i = 0;  (c = gline(i, &a)) != '\0';  i++)
64 	{
65 		at_switch(a);
66 		final_attr = a;
67 		if (c == '\b')
68 			putbs();
69 		else
70 			putchr(c);
71 	}
72 
73 	at_exit();
74 }
75 
76 static char obuf[OUTBUF_SIZE];
77 static char *ob = obuf;
78 
79 /*
80  * Flush buffered output.
81  *
82  * If we haven't displayed any file data yet,
83  * output messages on error output (file descriptor 2),
84  * otherwise output on standard output (file descriptor 1).
85  *
86  * This has the desirable effect of producing all
87  * error messages on error output if standard output
88  * is directed to a file.  It also does the same if
89  * we never produce any real output; for example, if
90  * the input file(s) cannot be opened.  If we do
91  * eventually produce output, code in edit() makes
92  * sure these messages can be seen before they are
93  * overwritten or scrolled away.
94  */
95 	public void
96 flush()
97 {
98 	register int n;
99 	register int fd;
100 
101 	n = ob - obuf;
102 	if (n == 0)
103 		return;
104 
105 #if MSDOS_COMPILER==MSOFTC
106 	if (is_tty && any_display)
107 	{
108 		*ob = '\0';
109 		_outtext(obuf);
110 		ob = obuf;
111 		return;
112 	}
113 #else
114 #if MSDOS_COMPILER==WIN32C || MSDOS_COMPILER==BORLANDC || MSDOS_COMPILER==DJGPPC
115 	if (is_tty && any_display)
116 	{
117 		*ob = '\0';
118 		if (ctldisp != OPT_ONPLUS)
119 			WIN32textout(obuf, ob - obuf);
120 		else
121 		{
122 			/*
123 			 * Look for SGR escape sequences, and convert them
124 			 * to color commands.  Replace bold, underline,
125 			 * and italic escapes into colors specified via
126 			 * the -D command-line option.
127 			 */
128 			char *anchor, *p, *p_next;
129 			unsigned char fg, bg;
130 			static unsigned char at;
131 #if MSDOS_COMPILER==WIN32C
132 			/* Screen colors used by 3x and 4x SGR commands. */
133 			static unsigned char screen_color[] = {
134 				0, /* BLACK */
135 				FOREGROUND_RED,
136 				FOREGROUND_GREEN,
137 				FOREGROUND_RED|FOREGROUND_GREEN,
138 				FOREGROUND_BLUE,
139 				FOREGROUND_BLUE|FOREGROUND_RED,
140 				FOREGROUND_BLUE|FOREGROUND_GREEN,
141 				FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED
142 			};
143 #else
144 			static enum COLORS screen_color[] = {
145 				BLACK, RED, GREEN, BROWN,
146 				BLUE, MAGENTA, CYAN, LIGHTGRAY
147 			};
148 #endif
149 
150 			for (anchor = p_next = obuf;
151 			     (p_next = memchr(p_next, ESC, ob - p_next)) != NULL; )
152 			{
153 				p = p_next;
154 				if (p[1] == '[')  /* "ESC-[" sequence */
155 				{
156 					if (p > anchor)
157 					{
158 						/*
159 						 * If some chars seen since
160 						 * the last escape sequence,
161 						 * write them out to the screen.
162 						 */
163 						WIN32textout(anchor, p-anchor);
164 						anchor = p;
165 					}
166 					p += 2;  /* Skip the "ESC-[" */
167 					if (is_ansi_end(*p))
168 					{
169 						/*
170 						 * Handle null escape sequence
171 						 * "ESC[m", which restores
172 						 * the normal color.
173 						 */
174 						p++;
175 						anchor = p_next = p;
176 						at = 0;
177 						WIN32setcolors(nm_fg_color, nm_bg_color);
178 						continue;
179 					}
180 					p_next = p;
181 
182 					/*
183 					 * Select foreground/background colors
184 					 * based on the escape sequence.
185 					 */
186 					fg = nm_fg_color;
187 					bg = nm_bg_color;
188 					while (!is_ansi_end(*p))
189 					{
190 						char *q;
191 						long code = strtol(p, &q, 10);
192 
193 						if (*q == '\0')
194 						{
195 							/*
196 							 * Incomplete sequence.
197 							 * Leave it unprocessed
198 							 * in the buffer.
199 							 */
200 							int slop = q - anchor;
201 							/* {{ strcpy args overlap! }} */
202 							strcpy(obuf, anchor);
203 							ob = &obuf[slop];
204 							return;
205 						}
206 
207 						if (q == p ||
208 						    code > 49 || code < 0 ||
209 						    (!is_ansi_end(*q) && *q != ';'))
210 						{
211 							p_next = q;
212 							break;
213 						}
214 						if (*q == ';')
215 							q++;
216 
217 						switch (code)
218 						{
219 						default:
220 						/* case 0: all attrs off */
221 							fg = nm_fg_color;
222 							bg = nm_bg_color;
223 							at = 0;
224 							break;
225 						case 1:	/* bold on */
226 							at |= 1;
227 							break;
228 						case 3:	/* italic on */
229 						case 7: /* inverse on */
230 							at |= 2;
231 							break;
232 						case 4:	/* underline on */
233 							at |= 4;
234 							break;
235 						case 5: /* slow blink on */
236 						case 6: /* fast blink on */
237 							at |= 8;
238 							break;
239 						case 8:	/* concealed on */
240 							fg = (bg & 7) | 8;
241 							break;
242 						case 22: /* bold off */
243 							at &= ~1;
244 							break;
245 						case 23: /* italic off */
246 						case 27: /* inverse off */
247 							at &= ~2;
248 							break;
249 						case 24: /* underline off */
250 							at &= ~4;
251 							break;
252 						case 30: case 31: case 32:
253 						case 33: case 34: case 35:
254 						case 36: case 37:
255 							fg = (fg & 8) | (screen_color[code - 30]);
256 							break;
257 						case 39: /* default fg */
258 							fg = nm_fg_color;
259 							break;
260 						case 40: case 41: case 42:
261 						case 43: case 44: case 45:
262 						case 46: case 47:
263 							bg = (bg & 8) | (screen_color[code - 40]);
264 							break;
265 						case 49: /* default fg */
266 							bg = nm_bg_color;
267 							break;
268 						}
269 						p = q;
270 					}
271 					if (!is_ansi_end(*p) || p == p_next)
272 						break;
273 					if (at & 1)
274 					{
275 						/*
276 						 * If \e[1m use defined bold
277 						 * color, else set intensity.
278 						 */
279 						if (p[-2] == '[')
280 						{
281 							fg = bo_fg_color;
282 							bg = bo_bg_color;
283 						} else
284 							fg |= 8;
285 					} else if (at & 2)
286 					{
287 						fg = so_fg_color;
288 						bg = so_bg_color;
289 					} else if (at & 4)
290 					{
291 						fg = ul_fg_color;
292 						bg = ul_bg_color;
293 					} else if (at & 8)
294 					{
295 						fg = bl_fg_color;
296 						bg = bl_bg_color;
297 					}
298 					fg &= 0xf;
299 					bg &= 0xf;
300 					WIN32setcolors(fg, bg);
301 					p_next = anchor = p + 1;
302 				} else
303 					p_next++;
304 			}
305 
306 			/* Output what's left in the buffer.  */
307 			WIN32textout(anchor, ob - anchor);
308 		}
309 		ob = obuf;
310 		return;
311 	}
312 #endif
313 #endif
314 	fd = (any_display) ? 1 : 2;
315 	if (write(fd, obuf, n) != n)
316 		screen_trashed = 1;
317 	ob = obuf;
318 }
319 
320 /*
321  * Output a character.
322  */
323 	public int
324 putchr(c)
325 	int c;
326 {
327 #if 0 /* fake UTF-8 output for testing */
328 	extern int utf_mode;
329 	if (utf_mode)
330 	{
331 		static char ubuf[MAX_UTF_CHAR_LEN];
332 		static int ubuf_len = 0;
333 		static int ubuf_index = 0;
334 		if (ubuf_len == 0)
335 		{
336 			ubuf_len = utf_len(c);
337 			ubuf_index = 0;
338 		}
339 		ubuf[ubuf_index++] = c;
340 		if (ubuf_index < ubuf_len)
341 			return c;
342 		c = get_wchar(ubuf) & 0xFF;
343 		ubuf_len = 0;
344 	}
345 #endif
346 	if (need_clr)
347 	{
348 		need_clr = 0;
349 		clear_bot();
350 	}
351 #if MSDOS_COMPILER
352 	if (c == '\n' && is_tty)
353 	{
354 		/* remove_top(1); */
355 		putchr('\r');
356 	}
357 #else
358 #ifdef _OSK
359 	if (c == '\n' && is_tty)  /* In OS-9, '\n' == 0x0D */
360 		putchr(0x0A);
361 #endif
362 #endif
363 	/*
364 	 * Some versions of flush() write to *ob, so we must flush
365 	 * when we are still one char from the end of obuf.
366 	 */
367 	if (ob >= &obuf[sizeof(obuf)-1])
368 		flush();
369 	*ob++ = c;
370 	at_prompt = 0;
371 	return (c);
372 }
373 
374 /*
375  * Output a string.
376  */
377 	public void
378 putstr(s)
379 	register char *s;
380 {
381 	while (*s != '\0')
382 		putchr(*s++);
383 }
384 
385 
386 /*
387  * Convert an integral type to a string.
388  */
389 #define TYPE_TO_A_FUNC(funcname, type) \
390 void funcname(num, buf) \
391 	type num; \
392 	char *buf; \
393 { \
394 	int neg = (num < 0); \
395 	char tbuf[INT_STRLEN_BOUND(num)+2]; \
396 	register char *s = tbuf + sizeof(tbuf); \
397 	if (neg) num = -num; \
398 	*--s = '\0'; \
399 	do { \
400 		*--s = (num % 10) + '0'; \
401 	} while ((num /= 10) != 0); \
402 	if (neg) *--s = '-'; \
403 	strcpy(buf, s); \
404 }
405 
406 TYPE_TO_A_FUNC(postoa, POSITION)
407 TYPE_TO_A_FUNC(linenumtoa, LINENUM)
408 TYPE_TO_A_FUNC(inttoa, int)
409 
410 /*
411  * Output an integer in a given radix.
412  */
413 	static int
414 iprint_int(num)
415 	int num;
416 {
417 	char buf[INT_STRLEN_BOUND(num)];
418 
419 	inttoa(num, buf);
420 	putstr(buf);
421 	return (strlen(buf));
422 }
423 
424 /*
425  * Output a line number in a given radix.
426  */
427 	static int
428 iprint_linenum(num)
429 	LINENUM num;
430 {
431 	char buf[INT_STRLEN_BOUND(num)];
432 
433 	linenumtoa(num, buf);
434 	putstr(buf);
435 	return (strlen(buf));
436 }
437 
438 /*
439  * This function implements printf-like functionality
440  * using a more portable argument list mechanism than printf's.
441  */
442 	static int
443 less_printf(fmt, parg)
444 	register char *fmt;
445 	PARG *parg;
446 {
447 	register char *s;
448 	register int col;
449 
450 	col = 0;
451 	while (*fmt != '\0')
452 	{
453 		if (*fmt != '%')
454 		{
455 			putchr(*fmt++);
456 			col++;
457 		} else
458 		{
459 			++fmt;
460 			switch (*fmt++)
461 			{
462 			case 's':
463 				s = parg->p_string;
464 				parg++;
465 				while (*s != '\0')
466 				{
467 					putchr(*s++);
468 					col++;
469 				}
470 				break;
471 			case 'd':
472 				col += iprint_int(parg->p_int);
473 				parg++;
474 				break;
475 			case 'n':
476 				col += iprint_linenum(parg->p_linenum);
477 				parg++;
478 				break;
479 			}
480 		}
481 	}
482 	return (col);
483 }
484 
485 /*
486  * Get a RETURN.
487  * If some other non-trivial char is pressed, unget it, so it will
488  * become the next command.
489  */
490 	public void
491 get_return()
492 {
493 	int c;
494 
495 #if ONLY_RETURN
496 	while ((c = getchr()) != '\n' && c != '\r')
497 		bell();
498 #else
499 	c = getchr();
500 	if (c != '\n' && c != '\r' && c != ' ' && c != READ_INTR)
501 		ungetcc(c);
502 #endif
503 }
504 
505 /*
506  * Output a message in the lower left corner of the screen
507  * and wait for carriage return.
508  */
509 	public void
510 error(fmt, parg)
511 	char *fmt;
512 	PARG *parg;
513 {
514 	int col = 0;
515 	static char return_to_continue[] = "  (press RETURN)";
516 
517 	errmsgs++;
518 
519 	if (any_display && is_tty)
520 	{
521 		if (!oldbot)
522 			squish_check();
523 		at_exit();
524 		clear_bot();
525 		at_enter(AT_STANDOUT);
526 		col += so_s_width;
527 	}
528 
529 	col += less_printf(fmt, parg);
530 
531 	if (!(any_display && is_tty))
532 	{
533 		putchr('\n');
534 		return;
535 	}
536 
537 	putstr(return_to_continue);
538 	at_exit();
539 	col += sizeof(return_to_continue) + so_e_width;
540 
541 	get_return();
542 	lower_left();
543     clear_eol();
544 
545 	if (col >= sc_width)
546 		/*
547 		 * Printing the message has probably scrolled the screen.
548 		 * {{ Unless the terminal doesn't have auto margins,
549 		 *    in which case we just hammered on the right margin. }}
550 		 */
551 		screen_trashed = 1;
552 
553 	flush();
554 }
555 
556 static char intr_to_abort[] = "... (interrupt to abort)";
557 
558 /*
559  * Output a message in the lower left corner of the screen
560  * and don't wait for carriage return.
561  * Usually used to warn that we are beginning a potentially
562  * time-consuming operation.
563  */
564 	public void
565 ierror(fmt, parg)
566 	char *fmt;
567 	PARG *parg;
568 {
569 	at_exit();
570 	clear_bot();
571 	at_enter(AT_STANDOUT);
572 	(void) less_printf(fmt, parg);
573 	putstr(intr_to_abort);
574 	at_exit();
575 	flush();
576 	need_clr = 1;
577 }
578 
579 /*
580  * Output a message in the lower left corner of the screen
581  * and return a single-character response.
582  */
583 	public int
584 query(fmt, parg)
585 	char *fmt;
586 	PARG *parg;
587 {
588 	register int c;
589 	int col = 0;
590 
591 	if (any_display && is_tty)
592 		clear_bot();
593 
594 	(void) less_printf(fmt, parg);
595 	c = getchr();
596 
597 	if (!(any_display && is_tty))
598 	{
599 		putchr('\n');
600 		return (c);
601 	}
602 
603 	lower_left();
604 	if (col >= sc_width)
605 		screen_trashed = 1;
606 	flush();
607 
608 	return (c);
609 }
610