1 /* $NetBSD: line.c,v 1.4 2013/09/04 19:44:21 tron Exp $ */
2
3 /*
4 * Copyright (C) 1984-2012 Mark Nudelman
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Less License, as specified in the README file.
8 *
9 * For more information, see the README file.
10 */
11
12
13 /*
14 * Routines to manipulate the "line buffer".
15 * The line buffer holds a line of output as it is being built
16 * in preparation for output to the screen.
17 */
18
19 #include "less.h"
20 #include "charset.h"
21
22 static char *linebuf = NULL; /* Buffer which holds the current output line */
23 static char *attr = NULL; /* Extension of linebuf to hold attributes */
24 public int size_linebuf = 0; /* Size of line buffer (and attr buffer) */
25
26 static int cshift; /* Current left-shift of output line buffer */
27 public int hshift; /* Desired left-shift of output line buffer */
28 public int tabstops[TABSTOP_MAX] = { 0 }; /* Custom tabstops */
29 public int ntabstops = 1; /* Number of tabstops */
30 public int tabdefault = 8; /* Default repeated tabstops */
31 public POSITION highest_hilite; /* Pos of last hilite in file found so far */
32
33 static int curr; /* Index into linebuf */
34 static int column; /* Printable length, accounting for
35 backspaces, etc. */
36 static int overstrike; /* Next char should overstrike previous char */
37 static int last_overstrike = AT_NORMAL;
38 static int is_null_line; /* There is no current line */
39 static int lmargin; /* Left margin */
40 static char pendc;
41 static POSITION pendpos;
42 static char *end_ansi_chars;
43 static char *mid_ansi_chars;
44
45 static int attr_swidth(int);
46 static int attr_ewidth(int);
47 static int do_append(LWCHAR, char *, POSITION);
48 extern int sigs;
49 extern int bs_mode;
50 extern int linenums;
51 extern int ctldisp;
52 extern int twiddle;
53 extern int binattr;
54 extern int status_col;
55 extern int auto_wrap, ignaw;
56 extern int bo_s_width, bo_e_width;
57 extern int ul_s_width, ul_e_width;
58 extern int bl_s_width, bl_e_width;
59 extern int so_s_width, so_e_width;
60 extern int sc_width, sc_height;
61 extern int utf_mode;
62 extern POSITION start_attnpos;
63 extern POSITION end_attnpos;
64
65 static char mbc_buf[MAX_UTF_CHAR_LEN];
66 static int mbc_buf_len = 0;
67 static int mbc_buf_index = 0;
68 static POSITION mbc_pos;
69
70 /*
71 * Initialize from environment variables.
72 */
73 public void
init_line()74 init_line()
75 {
76 end_ansi_chars = lgetenv("LESSANSIENDCHARS");
77 if (end_ansi_chars == NULL || *end_ansi_chars == '\0')
78 end_ansi_chars = "m";
79
80 mid_ansi_chars = lgetenv("LESSANSIMIDCHARS");
81 if (mid_ansi_chars == NULL || *mid_ansi_chars == '\0')
82 mid_ansi_chars = "0123456789;[?!\"'#%()*+ ";
83
84 linebuf = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
85 attr = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
86 size_linebuf = LINEBUF_SIZE;
87 }
88
89 /*
90 * Expand the line buffer.
91 */
92 static int
expand_linebuf()93 expand_linebuf()
94 {
95 /* Double the size of the line buffer. */
96 int new_size = size_linebuf * 2;
97
98 /* Just realloc to expand the buffer, if we can. */
99 #if HAVE_REALLOC
100 char *new_buf = (char *) realloc(linebuf, new_size);
101 char *new_attr = (char *) realloc(attr, new_size);
102 #else
103 char *new_buf = (char *) calloc(new_size, sizeof(char));
104 char *new_attr = (char *) calloc(new_size, sizeof(char));
105 #endif
106 if (new_buf == NULL || new_attr == NULL)
107 {
108 if (new_attr != NULL)
109 free(new_attr);
110 if (new_buf != NULL)
111 free(new_buf);
112 return 1;
113 }
114 #if HAVE_REALLOC
115 /*
116 * We realloc'd the buffers; they already have the old contents.
117 */
118 #if 0
119 memset(new_buf + size_linebuf, 0, new_size - size_linebuf);
120 memset(new_attr + size_linebuf, 0, new_size - size_linebuf);
121 #endif
122 #else
123 /*
124 * We just calloc'd the buffers; copy the old contents.
125 */
126 memcpy(new_buf, linebuf, size_linebuf * sizeof(char));
127 memcpy(new_attr, attr, size_linebuf * sizeof(char));
128 free(attr);
129 free(linebuf);
130 #endif
131 linebuf = new_buf;
132 attr = new_attr;
133 size_linebuf = new_size;
134 return 0;
135 }
136
137 /*
138 * Is a character ASCII?
139 */
140 public int
is_ascii_char(ch)141 is_ascii_char(ch)
142 LWCHAR ch;
143 {
144 return (ch <= 0x7F);
145 }
146
147 /*
148 * Rewind the line buffer.
149 */
150 public void
prewind()151 prewind()
152 {
153 curr = 0;
154 column = 0;
155 cshift = 0;
156 overstrike = 0;
157 last_overstrike = AT_NORMAL;
158 mbc_buf_len = 0;
159 is_null_line = 0;
160 pendc = '\0';
161 lmargin = 0;
162 if (status_col)
163 lmargin += 1;
164 }
165
166 /*
167 * Insert the line number (of the given position) into the line buffer.
168 */
169 public void
plinenum(pos)170 plinenum(pos)
171 POSITION pos;
172 {
173 register LINENUM linenum = 0;
174 register int i;
175
176 if (linenums == OPT_ONPLUS)
177 {
178 /*
179 * Get the line number and put it in the current line.
180 * {{ Note: since find_linenum calls forw_raw_line,
181 * it may seek in the input file, requiring the caller
182 * of plinenum to re-seek if necessary. }}
183 * {{ Since forw_raw_line modifies linebuf, we must
184 * do this first, before storing anything in linebuf. }}
185 */
186 linenum = find_linenum(pos);
187 }
188
189 /*
190 * Display a status column if the -J option is set.
191 */
192 if (status_col)
193 {
194 linebuf[curr] = ' ';
195 if (start_attnpos != NULL_POSITION &&
196 pos >= start_attnpos && pos < end_attnpos)
197 attr[curr] = AT_NORMAL|AT_HILITE;
198 else
199 attr[curr] = AT_NORMAL;
200 curr++;
201 column++;
202 }
203 /*
204 * Display the line number at the start of each line
205 * if the -N option is set.
206 */
207 if (linenums == OPT_ONPLUS)
208 {
209 char buf[INT_STRLEN_BOUND(pos) + 2];
210 int n;
211
212 linenumtoa(linenum, buf);
213 n = strlen(buf);
214 if (n < MIN_LINENUM_WIDTH)
215 n = MIN_LINENUM_WIDTH;
216 sprintf(linebuf+curr, "%*s ", n, buf);
217 n++; /* One space after the line number. */
218 for (i = 0; i < n; i++)
219 attr[curr+i] = AT_NORMAL;
220 curr += n;
221 column += n;
222 lmargin += n;
223 }
224
225 /*
226 * Append enough spaces to bring us to the lmargin.
227 */
228 while (column < lmargin)
229 {
230 linebuf[curr] = ' ';
231 attr[curr++] = AT_NORMAL;
232 column++;
233 }
234 }
235
236 /*
237 * Shift the input line left.
238 * This means discarding N printable chars at the start of the buffer.
239 */
240 static void
pshift(shift)241 pshift(shift)
242 int shift;
243 {
244 LWCHAR prev_ch = 0;
245 unsigned char c;
246 int shifted = 0;
247 int to;
248 int from;
249 int len;
250 int width;
251 int prev_attr;
252 int next_attr;
253
254 if (shift > column - lmargin)
255 shift = column - lmargin;
256 if (shift > curr - lmargin)
257 shift = curr - lmargin;
258
259 to = from = lmargin;
260 /*
261 * We keep on going when shifted == shift
262 * to get all combining chars.
263 */
264 while (shifted <= shift && from < curr)
265 {
266 c = linebuf[from];
267 if (ctldisp == OPT_ONPLUS && IS_CSI_START(c))
268 {
269 /* Keep cumulative effect. */
270 linebuf[to] = c;
271 attr[to++] = attr[from++];
272 while (from < curr && linebuf[from])
273 {
274 linebuf[to] = linebuf[from];
275 attr[to++] = attr[from];
276 if (!is_ansi_middle(linebuf[from++]))
277 break;
278 }
279 continue;
280 }
281
282 width = 0;
283
284 if (!IS_ASCII_OCTET(c) && utf_mode)
285 {
286 /* Assumes well-formedness validation already done. */
287 LWCHAR ch;
288
289 len = utf_len(c);
290 if (from + len > curr)
291 break;
292 ch = get_wchar(linebuf + from);
293 if (!is_composing_char(ch) && !is_combining_char(prev_ch, ch))
294 width = is_wide_char(ch) ? 2 : 1;
295 prev_ch = ch;
296 } else
297 {
298 len = 1;
299 if (c == '\b')
300 /* XXX - Incorrect if several '\b' in a row. */
301 width = (utf_mode && is_wide_char(prev_ch)) ? -2 : -1;
302 else if (!control_char(c))
303 width = 1;
304 prev_ch = 0;
305 }
306
307 if (width == 2 && shift - shifted == 1) {
308 /* Should never happen when called by pshift_all(). */
309 attr[to] = attr[from];
310 /*
311 * Assume a wide_char will never be the first half of a
312 * combining_char pair, so reset prev_ch in case we're
313 * followed by a '\b'.
314 */
315 prev_ch = linebuf[to++] = ' ';
316 from += len;
317 shifted++;
318 continue;
319 }
320
321 /* Adjust width for magic cookies. */
322 prev_attr = (to > 0) ? attr[to-1] : AT_NORMAL;
323 next_attr = (from + len < curr) ? attr[from + len] : prev_attr;
324 if (!is_at_equiv(attr[from], prev_attr) &&
325 !is_at_equiv(attr[from], next_attr))
326 {
327 width += attr_swidth(attr[from]);
328 if (from + len < curr)
329 width += attr_ewidth(attr[from]);
330 if (is_at_equiv(prev_attr, next_attr))
331 {
332 width += attr_ewidth(prev_attr);
333 if (from + len < curr)
334 width += attr_swidth(next_attr);
335 }
336 }
337
338 if (shift - shifted < width)
339 break;
340 from += len;
341 shifted += width;
342 if (shifted < 0)
343 shifted = 0;
344 }
345 while (from < curr)
346 {
347 linebuf[to] = linebuf[from];
348 attr[to++] = attr[from++];
349 }
350 curr = to;
351 column -= shifted;
352 cshift += shifted;
353 }
354
355 /*
356 *
357 */
358 public void
pshift_all()359 pshift_all()
360 {
361 pshift(column);
362 }
363
364 /*
365 * Return the printing width of the start (enter) sequence
366 * for a given character attribute.
367 */
368 static int
attr_swidth(a)369 attr_swidth(a)
370 int a;
371 {
372 int w = 0;
373
374 a = apply_at_specials(a);
375
376 if (a & AT_UNDERLINE)
377 w += ul_s_width;
378 if (a & AT_BOLD)
379 w += bo_s_width;
380 if (a & AT_BLINK)
381 w += bl_s_width;
382 if (a & AT_STANDOUT)
383 w += so_s_width;
384
385 return w;
386 }
387
388 /*
389 * Return the printing width of the end (exit) sequence
390 * for a given character attribute.
391 */
392 static int
attr_ewidth(a)393 attr_ewidth(a)
394 int a;
395 {
396 int w = 0;
397
398 a = apply_at_specials(a);
399
400 if (a & AT_UNDERLINE)
401 w += ul_e_width;
402 if (a & AT_BOLD)
403 w += bo_e_width;
404 if (a & AT_BLINK)
405 w += bl_e_width;
406 if (a & AT_STANDOUT)
407 w += so_e_width;
408
409 return w;
410 }
411
412 /*
413 * Return the printing width of a given character and attribute,
414 * if the character were added to the current position in the line buffer.
415 * Adding a character with a given attribute may cause an enter or exit
416 * attribute sequence to be inserted, so this must be taken into account.
417 */
418 static int
pwidth(ch,a,prev_ch)419 pwidth(ch, a, prev_ch)
420 LWCHAR ch;
421 int a;
422 LWCHAR prev_ch;
423 {
424 int w;
425
426 if (ch == '\b')
427 /*
428 * Backspace moves backwards one or two positions.
429 * XXX - Incorrect if several '\b' in a row.
430 */
431 return (utf_mode && is_wide_char(prev_ch)) ? -2 : -1;
432
433 if (!utf_mode || is_ascii_char(ch))
434 {
435 if (control_char((char)ch))
436 {
437 /*
438 * Control characters do unpredictable things,
439 * so we don't even try to guess; say it doesn't move.
440 * This can only happen if the -r flag is in effect.
441 */
442 return (0);
443 }
444 } else
445 {
446 if (is_composing_char(ch) || is_combining_char(prev_ch, ch))
447 {
448 /*
449 * Composing and combining chars take up no space.
450 *
451 * Some terminals, upon failure to compose a
452 * composing character with the character(s) that
453 * precede(s) it will actually take up one column
454 * for the composing character; there isn't much
455 * we could do short of testing the (complex)
456 * composition process ourselves and printing
457 * a binary representation when it fails.
458 */
459 return (0);
460 }
461 }
462
463 /*
464 * Other characters take one or two columns,
465 * plus the width of any attribute enter/exit sequence.
466 */
467 w = 1;
468 if (is_wide_char(ch))
469 w++;
470 if (curr > 0 && !is_at_equiv(attr[curr-1], a))
471 w += attr_ewidth(attr[curr-1]);
472 if ((apply_at_specials(a) != AT_NORMAL) &&
473 (curr == 0 || !is_at_equiv(attr[curr-1], a)))
474 w += attr_swidth(a);
475 return (w);
476 }
477
478 /*
479 * Delete to the previous base character in the line buffer.
480 * Return 1 if one is found.
481 */
482 static int
backc()483 backc()
484 {
485 LWCHAR prev_ch;
486 char *p = linebuf + curr;
487 LWCHAR ch = step_char(&p, -1, linebuf + lmargin);
488 int width;
489
490 /* This assumes that there is no '\b' in linebuf. */
491 while ( curr > lmargin
492 && column > lmargin
493 && (!(attr[curr - 1] & (AT_ANSI|AT_BINARY))))
494 {
495 curr = p - linebuf;
496 prev_ch = step_char(&p, -1, linebuf + lmargin);
497 width = pwidth(ch, attr[curr], prev_ch);
498 column -= width;
499 if (width > 0)
500 return 1;
501 ch = prev_ch;
502 }
503
504 return 0;
505 }
506
507 /*
508 * Are we currently within a recognized ANSI escape sequence?
509 */
510 static int
in_ansi_esc_seq()511 in_ansi_esc_seq()
512 {
513 char *p;
514
515 /*
516 * Search backwards for either an ESC (which means we ARE in a seq);
517 * or an end char (which means we're NOT in a seq).
518 */
519 for (p = &linebuf[curr]; p > linebuf; )
520 {
521 LWCHAR ch = step_char(&p, -1, linebuf);
522 if (IS_CSI_START(ch))
523 return (1);
524 if (!is_ansi_middle(ch))
525 return (0);
526 }
527 return (0);
528 }
529
530 /*
531 * Is a character the end of an ANSI escape sequence?
532 */
533 public int
is_ansi_end(ch)534 is_ansi_end(ch)
535 LWCHAR ch;
536 {
537 if (!is_ascii_char(ch))
538 return (0);
539 return (strchr(end_ansi_chars, (char) ch) != NULL);
540 }
541
542 /*
543 *
544 */
545 public int
is_ansi_middle(ch)546 is_ansi_middle(ch)
547 LWCHAR ch;
548 {
549 if (!is_ascii_char(ch))
550 return (0);
551 if (is_ansi_end(ch))
552 return (0);
553 return (strchr(mid_ansi_chars, (char) ch) != NULL);
554 }
555
556 /*
557 * Append a character and attribute to the line buffer.
558 */
559 #define STORE_CHAR(ch,a,rep,pos) \
560 do { \
561 if (store_char((ch),(a),(rep),(pos))) return (1); \
562 } while (0)
563
564 static int
store_char(ch,a,rep,pos)565 store_char(ch, a, rep, pos)
566 LWCHAR ch;
567 int a;
568 char *rep;
569 POSITION pos;
570 {
571 int w;
572 int replen;
573 char cs;
574
575 w = (a & (AT_UNDERLINE|AT_BOLD)); /* Pre-use w. */
576 if (w != AT_NORMAL)
577 last_overstrike = w;
578
579 #if HILITE_SEARCH
580 {
581 int matches;
582 if (is_hilited(pos, pos+1, 0, &matches))
583 {
584 /*
585 * This character should be highlighted.
586 * Override the attribute passed in.
587 */
588 if (a != AT_ANSI)
589 {
590 if (highest_hilite != NULL_POSITION &&
591 pos > highest_hilite)
592 highest_hilite = pos;
593 a |= AT_HILITE;
594 }
595 }
596 }
597 #endif
598
599 if (ctldisp == OPT_ONPLUS && in_ansi_esc_seq())
600 {
601 if (!is_ansi_end(ch) && !is_ansi_middle(ch)) {
602 /* Remove whole unrecognized sequence. */
603 char *p = &linebuf[curr];
604 LWCHAR bch;
605 do {
606 bch = step_char(&p, -1, linebuf);
607 } while (p > linebuf && !IS_CSI_START(bch));
608 curr = p - linebuf;
609 return 0;
610 }
611 a = AT_ANSI; /* Will force re-AT_'ing around it. */
612 w = 0;
613 }
614 else if (ctldisp == OPT_ONPLUS && IS_CSI_START(ch))
615 {
616 a = AT_ANSI; /* Will force re-AT_'ing around it. */
617 w = 0;
618 }
619 else
620 {
621 char *p = &linebuf[curr];
622 LWCHAR prev_ch = step_char(&p, -1, linebuf);
623 w = pwidth(ch, a, prev_ch);
624 }
625
626 if (ctldisp != OPT_ON && column + w + attr_ewidth(a) > sc_width)
627 /*
628 * Won't fit on screen.
629 */
630 return (1);
631
632 if (rep == NULL)
633 {
634 cs = (char) ch;
635 rep = &cs;
636 replen = 1;
637 } else
638 {
639 replen = utf_len(rep[0]);
640 }
641 if (curr + replen >= size_linebuf-6)
642 {
643 /*
644 * Won't fit in line buffer.
645 * Try to expand it.
646 */
647 if (expand_linebuf())
648 return (1);
649 }
650
651 while (replen-- > 0)
652 {
653 linebuf[curr] = *rep++;
654 attr[curr] = a;
655 curr++;
656 }
657 column += w;
658 return (0);
659 }
660
661 /*
662 * Append a tab to the line buffer.
663 * Store spaces to represent the tab.
664 */
665 #define STORE_TAB(a,pos) \
666 do { if (store_tab((a),(pos))) return (1); } while (0)
667
668 static int
store_tab(attr,pos)669 store_tab(attr, pos)
670 int attr;
671 POSITION pos;
672 {
673 int to_tab = column + cshift - lmargin;
674 int i;
675
676 if (ntabstops < 2 || to_tab >= tabstops[ntabstops-1])
677 to_tab = tabdefault -
678 ((to_tab - tabstops[ntabstops-1]) % tabdefault);
679 else
680 {
681 for (i = ntabstops - 2; i >= 0; i--)
682 if (to_tab >= tabstops[i])
683 break;
684 to_tab = tabstops[i+1] - to_tab;
685 }
686
687 if (column + to_tab - 1 + pwidth(' ', attr, 0) + attr_ewidth(attr) > sc_width)
688 return 1;
689
690 do {
691 STORE_CHAR(' ', attr, " ", pos);
692 } while (--to_tab > 0);
693 return 0;
694 }
695
696 #define STORE_PRCHAR(c, pos) \
697 do { if (store_prchar((c), (pos))) return 1; } while (0)
698
699 static int
store_prchar(c,pos)700 store_prchar(c, pos)
701 char c;
702 POSITION pos;
703 {
704 char *s;
705
706 /*
707 * Convert to printable representation.
708 */
709 s = prchar(c);
710
711 /*
712 * Make sure we can get the entire representation
713 * of the character on this line.
714 */
715 if (column + (int) strlen(s) - 1 +
716 pwidth(' ', binattr, 0) + attr_ewidth(binattr) > sc_width)
717 return 1;
718
719 for ( ; *s != 0; s++)
720 STORE_CHAR(*s, AT_BINARY, NULL, pos);
721
722 return 0;
723 }
724
725 static int
flush_mbc_buf(pos)726 flush_mbc_buf(pos)
727 POSITION pos;
728 {
729 int i;
730
731 for (i = 0; i < mbc_buf_index; i++)
732 if (store_prchar(mbc_buf[i], pos))
733 return mbc_buf_index - i;
734
735 return 0;
736 }
737
738 /*
739 * Append a character to the line buffer.
740 * Expand tabs into spaces, handle underlining, boldfacing, etc.
741 * Returns 0 if ok, 1 if couldn't fit in buffer.
742 */
743 public int
pappend(c,pos)744 pappend(c, pos)
745 char c;
746 POSITION pos;
747 {
748 int r;
749
750 if (pendc)
751 {
752 if (do_append(pendc, NULL, pendpos))
753 /*
754 * Oops. We've probably lost the char which
755 * was in pendc, since caller won't back up.
756 */
757 return (1);
758 pendc = '\0';
759 }
760
761 if (c == '\r' && bs_mode == BS_SPECIAL)
762 {
763 if (mbc_buf_len > 0) /* utf_mode must be on. */
764 {
765 /* Flush incomplete (truncated) sequence. */
766 r = flush_mbc_buf(mbc_pos);
767 mbc_buf_index = r + 1;
768 mbc_buf_len = 0;
769 if (r)
770 return (mbc_buf_index);
771 }
772
773 /*
774 * Don't put the CR into the buffer until we see
775 * the next char. If the next char is a newline,
776 * discard the CR.
777 */
778 pendc = c;
779 pendpos = pos;
780 return (0);
781 }
782
783 if (!utf_mode)
784 {
785 r = do_append((LWCHAR) c, NULL, pos);
786 } else
787 {
788 /* Perform strict validation in all possible cases. */
789 if (mbc_buf_len == 0)
790 {
791 retry:
792 mbc_buf_index = 1;
793 *mbc_buf = c;
794 if (IS_ASCII_OCTET(c))
795 r = do_append((LWCHAR) c, NULL, pos);
796 else if (IS_UTF8_LEAD(c))
797 {
798 mbc_buf_len = utf_len(c);
799 mbc_pos = pos;
800 return (0);
801 } else
802 /* UTF8_INVALID or stray UTF8_TRAIL */
803 r = flush_mbc_buf(pos);
804 } else if (IS_UTF8_TRAIL(c))
805 {
806 mbc_buf[mbc_buf_index++] = c;
807 if (mbc_buf_index < mbc_buf_len)
808 return (0);
809 if (is_utf8_well_formed(mbc_buf))
810 r = do_append(get_wchar(mbc_buf), mbc_buf, mbc_pos);
811 else
812 /* Complete, but not shortest form, sequence. */
813 mbc_buf_index = r = flush_mbc_buf(mbc_pos);
814 mbc_buf_len = 0;
815 } else
816 {
817 /* Flush incomplete (truncated) sequence. */
818 r = flush_mbc_buf(mbc_pos);
819 mbc_buf_index = r + 1;
820 mbc_buf_len = 0;
821 /* Handle new char. */
822 if (!r)
823 goto retry;
824 }
825 }
826
827 /*
828 * If we need to shift the line, do it.
829 * But wait until we get to at least the middle of the screen,
830 * so shifting it doesn't affect the chars we're currently
831 * pappending. (Bold & underline can get messed up otherwise.)
832 */
833 if (cshift < hshift && column > sc_width / 2)
834 {
835 linebuf[curr] = '\0';
836 pshift(hshift - cshift);
837 }
838 if (r)
839 {
840 /* How many chars should caller back up? */
841 r = (!utf_mode) ? 1 : mbc_buf_index;
842 }
843 return (r);
844 }
845
846 static int
do_append(ch,rep,pos)847 do_append(ch, rep, pos)
848 LWCHAR ch;
849 char *rep;
850 POSITION pos;
851 {
852 register int a;
853 LWCHAR prev_ch;
854
855 a = AT_NORMAL;
856
857 if (ch == '\b')
858 {
859 if (bs_mode == BS_CONTROL)
860 goto do_control_char;
861
862 /*
863 * A better test is needed here so we don't
864 * backspace over part of the printed
865 * representation of a binary character.
866 */
867 if ( curr <= lmargin
868 || column <= lmargin
869 || (attr[curr - 1] & (AT_ANSI|AT_BINARY)))
870 STORE_PRCHAR('\b', pos);
871 else if (bs_mode == BS_NORMAL)
872 STORE_CHAR(ch, AT_NORMAL, NULL, pos);
873 else if (bs_mode == BS_SPECIAL)
874 overstrike = backc();
875
876 return 0;
877 }
878
879 if (overstrike > 0)
880 {
881 /*
882 * Overstrike the character at the current position
883 * in the line buffer. This will cause either
884 * underline (if a "_" is overstruck),
885 * bold (if an identical character is overstruck),
886 * or just deletion of the character in the buffer.
887 */
888 overstrike = utf_mode ? -1 : 0;
889 /* To be correct, this must be a base character. */
890 prev_ch = get_wchar(linebuf + curr);
891 a = attr[curr];
892 if (ch == prev_ch)
893 {
894 /*
895 * Overstriking a char with itself means make it bold.
896 * But overstriking an underscore with itself is
897 * ambiguous. It could mean make it bold, or
898 * it could mean make it underlined.
899 * Use the previous overstrike to resolve it.
900 */
901 if (ch == '_')
902 {
903 if ((a & (AT_BOLD|AT_UNDERLINE)) != AT_NORMAL)
904 a |= (AT_BOLD|AT_UNDERLINE);
905 else if (last_overstrike != AT_NORMAL)
906 a |= last_overstrike;
907 else
908 a |= AT_BOLD;
909 } else
910 a |= AT_BOLD;
911 } else if (ch == '_')
912 {
913 a |= AT_UNDERLINE;
914 ch = prev_ch;
915 rep = linebuf + curr;
916 } else if (prev_ch == '_')
917 {
918 a |= AT_UNDERLINE;
919 }
920 /* Else we replace prev_ch, but we keep its attributes. */
921 } else if (overstrike < 0)
922 {
923 if ( is_composing_char(ch)
924 || is_combining_char(get_wchar(linebuf + curr), ch))
925 /* Continuation of the same overstrike. */
926 a = last_overstrike;
927 else
928 overstrike = 0;
929 }
930
931 if (ch == '\t')
932 {
933 /*
934 * Expand a tab into spaces.
935 */
936 switch (bs_mode)
937 {
938 case BS_CONTROL:
939 goto do_control_char;
940 case BS_NORMAL:
941 case BS_SPECIAL:
942 STORE_TAB(a, pos);
943 break;
944 }
945 } else if ((!utf_mode || is_ascii_char(ch)) && control_char((char)ch))
946 {
947 do_control_char:
948 if (ctldisp == OPT_ON || (ctldisp == OPT_ONPLUS && IS_CSI_START(ch)))
949 {
950 /*
951 * Output as a normal character.
952 */
953 STORE_CHAR(ch, AT_NORMAL, rep, pos);
954 } else
955 {
956 STORE_PRCHAR((char) ch, pos);
957 }
958 } else if (utf_mode && ctldisp != OPT_ON && is_ubin_char(ch))
959 {
960 char *s;
961
962 s = prutfchar(ch);
963
964 if (column + (int) strlen(s) - 1 +
965 pwidth(' ', binattr, 0) + attr_ewidth(binattr) > sc_width)
966 return (1);
967
968 for ( ; *s != 0; s++)
969 STORE_CHAR(*s, AT_BINARY, NULL, pos);
970 } else
971 {
972 STORE_CHAR(ch, a, rep, pos);
973 }
974 return (0);
975 }
976
977 /*
978 *
979 */
980 public int
pflushmbc()981 pflushmbc()
982 {
983 int r = 0;
984
985 if (mbc_buf_len > 0)
986 {
987 /* Flush incomplete (truncated) sequence. */
988 r = flush_mbc_buf(mbc_pos);
989 mbc_buf_len = 0;
990 }
991 return r;
992 }
993
994 /*
995 * Terminate the line in the line buffer.
996 */
997 public void
pdone(endline,forw)998 pdone(endline, forw)
999 int endline;
1000 int forw;
1001 {
1002 (void) pflushmbc();
1003
1004 if (pendc && (pendc != '\r' || !endline))
1005 /*
1006 * If we had a pending character, put it in the buffer.
1007 * But discard a pending CR if we are at end of line
1008 * (that is, discard the CR in a CR/LF sequence).
1009 */
1010 (void) do_append(pendc, NULL, pendpos);
1011
1012 /*
1013 * Make sure we've shifted the line, if we need to.
1014 */
1015 if (cshift < hshift)
1016 pshift(hshift - cshift);
1017
1018 if (ctldisp == OPT_ONPLUS && is_ansi_end('m'))
1019 {
1020 /* Switch to normal attribute at end of line. */
1021 char *p = "\033[m";
1022 for ( ; *p != '\0'; p++)
1023 {
1024 linebuf[curr] = *p;
1025 attr[curr++] = AT_ANSI;
1026 }
1027 }
1028
1029 /*
1030 * Add a newline if necessary,
1031 * and append a '\0' to the end of the line.
1032 * We output a newline if we're not at the right edge of the screen,
1033 * or if the terminal doesn't auto wrap,
1034 * or if this is really the end of the line AND the terminal ignores
1035 * a newline at the right edge.
1036 * (In the last case we don't want to output a newline if the terminal
1037 * doesn't ignore it since that would produce an extra blank line.
1038 * But we do want to output a newline if the terminal ignores it in case
1039 * the next line is blank. In that case the single newline output for
1040 * that blank line would be ignored!)
1041 */
1042 if (column < sc_width || !auto_wrap || (endline && ignaw) || ctldisp == OPT_ON)
1043 {
1044 linebuf[curr] = '\n';
1045 attr[curr] = AT_NORMAL;
1046 curr++;
1047 }
1048 else if (ignaw && column >= sc_width && forw)
1049 {
1050 /*
1051 * Terminals with "ignaw" don't wrap until they *really* need
1052 * to, i.e. when the character *after* the last one to fit on a
1053 * line is output. But they are too hard to deal with when they
1054 * get in the state where a full screen width of characters
1055 * have been output but the cursor is sitting on the right edge
1056 * instead of at the start of the next line.
1057 * So we nudge them into wrapping by outputting a space
1058 * character plus a backspace. But do this only if moving
1059 * forward; if we're moving backward and drawing this line at
1060 * the top of the screen, the space would overwrite the first
1061 * char on the next line. We don't need to do this "nudge"
1062 * at the top of the screen anyway.
1063 */
1064 linebuf[curr] = ' ';
1065 attr[curr++] = AT_NORMAL;
1066 linebuf[curr] = '\b';
1067 attr[curr++] = AT_NORMAL;
1068 }
1069 linebuf[curr] = '\0';
1070 attr[curr] = AT_NORMAL;
1071 }
1072
1073 /*
1074 *
1075 */
1076 public void
set_status_col(c)1077 set_status_col(c)
1078 char c;
1079 {
1080 linebuf[0] = c;
1081 attr[0] = AT_NORMAL|AT_HILITE;
1082 }
1083
1084 /*
1085 * Get a character from the current line.
1086 * Return the character as the function return value,
1087 * and the character attribute in *ap.
1088 */
1089 public int
gline(i,ap)1090 gline(i, ap)
1091 register int i;
1092 register int *ap;
1093 {
1094 if (is_null_line)
1095 {
1096 /*
1097 * If there is no current line, we pretend the line is
1098 * either "~" or "", depending on the "twiddle" flag.
1099 */
1100 if (twiddle)
1101 {
1102 if (i == 0)
1103 {
1104 *ap = AT_BOLD;
1105 return '~';
1106 }
1107 --i;
1108 }
1109 /* Make sure we're back to AT_NORMAL before the '\n'. */
1110 *ap = AT_NORMAL;
1111 return i ? '\0' : '\n';
1112 }
1113
1114 *ap = attr[i];
1115 return (linebuf[i] & 0xFF);
1116 }
1117
1118 /*
1119 * Indicate that there is no current line.
1120 */
1121 public void
null_line()1122 null_line()
1123 {
1124 is_null_line = 1;
1125 cshift = 0;
1126 }
1127
1128 /*
1129 * Analogous to forw_line(), but deals with "raw lines":
1130 * lines which are not split for screen width.
1131 * {{ This is supposed to be more efficient than forw_line(). }}
1132 */
1133 public POSITION
forw_raw_line(curr_pos,linep,line_lenp)1134 forw_raw_line(curr_pos, linep, line_lenp)
1135 POSITION curr_pos;
1136 char **linep;
1137 int *line_lenp;
1138 {
1139 register int n;
1140 register int c;
1141 POSITION new_pos;
1142
1143 if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
1144 (c = ch_forw_get()) == EOI)
1145 return (NULL_POSITION);
1146
1147 n = 0;
1148 for (;;)
1149 {
1150 if (c == '\n' || c == EOI || ABORT_SIGS())
1151 {
1152 new_pos = ch_tell();
1153 break;
1154 }
1155 if (n >= size_linebuf-1)
1156 {
1157 if (expand_linebuf())
1158 {
1159 /*
1160 * Overflowed the input buffer.
1161 * Pretend the line ended here.
1162 */
1163 new_pos = ch_tell() - 1;
1164 break;
1165 }
1166 }
1167 linebuf[n++] = c;
1168 c = ch_forw_get();
1169 }
1170 linebuf[n] = '\0';
1171 if (linep != NULL)
1172 *linep = linebuf;
1173 if (line_lenp != NULL)
1174 *line_lenp = n;
1175 return (new_pos);
1176 }
1177
1178 /*
1179 * Analogous to back_line(), but deals with "raw lines".
1180 * {{ This is supposed to be more efficient than back_line(). }}
1181 */
1182 public POSITION
back_raw_line(curr_pos,linep,line_lenp)1183 back_raw_line(curr_pos, linep, line_lenp)
1184 POSITION curr_pos;
1185 char **linep;
1186 int *line_lenp;
1187 {
1188 register int n;
1189 register int c;
1190 POSITION new_pos;
1191
1192 if (curr_pos == NULL_POSITION || curr_pos <= ch_zero() ||
1193 ch_seek(curr_pos-1))
1194 return (NULL_POSITION);
1195
1196 n = size_linebuf;
1197 linebuf[--n] = '\0';
1198 for (;;)
1199 {
1200 c = ch_back_get();
1201 if (c == '\n' || ABORT_SIGS())
1202 {
1203 /*
1204 * This is the newline ending the previous line.
1205 * We have hit the beginning of the line.
1206 */
1207 new_pos = ch_tell() + 1;
1208 break;
1209 }
1210 if (c == EOI)
1211 {
1212 /*
1213 * We have hit the beginning of the file.
1214 * This must be the first line in the file.
1215 * This must, of course, be the beginning of the line.
1216 */
1217 new_pos = ch_zero();
1218 break;
1219 }
1220 if (n <= 0)
1221 {
1222 int old_size_linebuf = size_linebuf;
1223 char *fm;
1224 char *to;
1225 if (expand_linebuf())
1226 {
1227 /*
1228 * Overflowed the input buffer.
1229 * Pretend the line ended here.
1230 */
1231 new_pos = ch_tell() + 1;
1232 break;
1233 }
1234 /*
1235 * Shift the data to the end of the new linebuf.
1236 */
1237 for (fm = linebuf + old_size_linebuf - 1,
1238 to = linebuf + size_linebuf - 1;
1239 fm >= linebuf; fm--, to--)
1240 *to = *fm;
1241 n = size_linebuf - old_size_linebuf;
1242 }
1243 linebuf[--n] = c;
1244 }
1245 if (linep != NULL)
1246 *linep = &linebuf[n];
1247 if (line_lenp != NULL)
1248 *line_lenp = size_linebuf - 1 - n;
1249 return (new_pos);
1250 }
1251