2 * Copyright (C) 1984-2014 Mark Nudelman
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.
7 * For more information, see the README file.
12 * Routines to manipulate the "line buffer".
13 * The line buffer holds a line of output as it is being built
14 * in preparation for output to the screen.
20 static char *linebuf
= NULL
; /* Buffer which holds the current output line */
21 static char *attr
= NULL
; /* Extension of linebuf to hold attributes */
22 public int size_linebuf
= 0; /* Size of line buffer (and attr buffer) */
24 static int cshift
; /* Current left-shift of output line buffer */
25 public int hshift
; /* Desired left-shift of output line buffer */
26 public int tabstops
[TABSTOP_MAX
] = { 0 }; /* Custom tabstops */
27 public int ntabstops
= 1; /* Number of tabstops */
28 public int tabdefault
= 8; /* Default repeated tabstops */
29 public POSITION highest_hilite
; /* Pos of last hilite in file found so far */
31 static int curr
; /* Index into linebuf */
32 static int column
; /* Printable length, accounting for
34 static int overstrike
; /* Next char should overstrike previous char */
35 static int last_overstrike
= AT_NORMAL
;
36 static int is_null_line
; /* There is no current line */
37 static int lmargin
; /* Left margin */
39 static POSITION pendpos
;
40 static char *end_ansi_chars
;
41 static char *mid_ansi_chars
;
43 static int attr_swidth();
44 static int attr_ewidth();
45 static int do_append();
53 extern int status_col
;
54 extern int auto_wrap
, ignaw
;
55 extern int bo_s_width
, bo_e_width
;
56 extern int ul_s_width
, ul_e_width
;
57 extern int bl_s_width
, bl_e_width
;
58 extern int so_s_width
, so_e_width
;
59 extern int sc_width
, sc_height
;
61 extern POSITION start_attnpos
;
62 extern POSITION end_attnpos
;
64 static char mbc_buf
[MAX_UTF_CHAR_LEN
];
65 static int mbc_buf_len
= 0;
66 static int mbc_buf_index
= 0;
67 static POSITION mbc_pos
;
70 * Initialize from environment variables.
75 end_ansi_chars
= lgetenv("LESSANSIENDCHARS");
76 if (end_ansi_chars
== NULL
|| *end_ansi_chars
== '\0')
79 mid_ansi_chars
= lgetenv("LESSANSIMIDCHARS");
80 if (mid_ansi_chars
== NULL
|| *mid_ansi_chars
== '\0')
81 mid_ansi_chars
= "0123456789:;[?!\"'#%()*+ ";
83 linebuf
= (char *) ecalloc(LINEBUF_SIZE
, sizeof(char));
84 attr
= (char *) ecalloc(LINEBUF_SIZE
, sizeof(char));
85 size_linebuf
= LINEBUF_SIZE
;
89 * Expand the line buffer.
94 /* Double the size of the line buffer. */
95 int new_size
= size_linebuf
* 2;
97 /* Just realloc to expand the buffer, if we can. */
99 char *new_buf
= (char *) realloc(linebuf
, new_size
);
100 char *new_attr
= (char *) realloc(attr
, new_size
);
102 char *new_buf
= (char *) calloc(new_size
, sizeof(char));
103 char *new_attr
= (char *) calloc(new_size
, sizeof(char));
105 if (new_buf
== NULL
|| new_attr
== NULL
)
107 if (new_attr
!= NULL
)
115 * We realloc'd the buffers; they already have the old contents.
118 memset(new_buf
+ size_linebuf
, 0, new_size
- size_linebuf
);
119 memset(new_attr
+ size_linebuf
, 0, new_size
- size_linebuf
);
123 * We just calloc'd the buffers; copy the old contents.
125 memcpy(new_buf
, linebuf
, size_linebuf
* sizeof(char));
126 memcpy(new_attr
, attr
, size_linebuf
* sizeof(char));
132 size_linebuf
= new_size
;
137 * Is a character ASCII?
147 * Rewind the line buffer.
156 last_overstrike
= AT_NORMAL
;
166 * Insert the line number (of the given position) into the line buffer.
172 register LINENUM linenum
= 0;
175 if (linenums
== OPT_ONPLUS
)
178 * Get the line number and put it in the current line.
179 * {{ Note: since find_linenum calls forw_raw_line,
180 * it may seek in the input file, requiring the caller
181 * of plinenum to re-seek if necessary. }}
182 * {{ Since forw_raw_line modifies linebuf, we must
183 * do this first, before storing anything in linebuf. }}
185 linenum
= find_linenum(pos
);
189 * Display a status column if the -J option is set.
194 if (start_attnpos
!= NULL_POSITION
&&
195 pos
>= start_attnpos
&& pos
< end_attnpos
)
196 attr
[curr
] = AT_NORMAL
|AT_HILITE
;
198 attr
[curr
] = AT_NORMAL
;
203 * Display the line number at the start of each line
204 * if the -N option is set.
206 if (linenums
== OPT_ONPLUS
)
208 char buf
[INT_STRLEN_BOUND(pos
) + 2];
211 linenumtoa(linenum
, buf
);
212 n
= (int) strlen(buf
);
213 if (n
< MIN_LINENUM_WIDTH
)
214 n
= MIN_LINENUM_WIDTH
;
215 sprintf(linebuf
+curr
, "%*s ", n
, buf
);
216 n
++; /* One space after the line number. */
217 for (i
= 0; i
< n
; i
++)
218 attr
[curr
+i
] = AT_NORMAL
;
225 * Append enough spaces to bring us to the lmargin.
227 while (column
< lmargin
)
230 attr
[curr
++] = AT_NORMAL
;
236 * Shift the input line left.
237 * This means discarding N printable chars at the start of the buffer.
253 if (shift
> column
- lmargin
)
254 shift
= column
- lmargin
;
255 if (shift
> curr
- lmargin
)
256 shift
= curr
- lmargin
;
260 * We keep on going when shifted == shift
261 * to get all combining chars.
263 while (shifted
<= shift
&& from
< curr
)
266 if (ctldisp
== OPT_ONPLUS
&& IS_CSI_START(c
))
268 /* Keep cumulative effect. */
270 attr
[to
++] = attr
[from
++];
271 while (from
< curr
&& linebuf
[from
])
273 linebuf
[to
] = linebuf
[from
];
274 attr
[to
++] = attr
[from
];
275 if (!is_ansi_middle(linebuf
[from
++]))
283 if (!IS_ASCII_OCTET(c
) && utf_mode
)
285 /* Assumes well-formedness validation already done. */
289 if (from
+ len
> curr
)
291 ch
= get_wchar(linebuf
+ from
);
292 if (!is_composing_char(ch
) && !is_combining_char(prev_ch
, ch
))
293 width
= is_wide_char(ch
) ? 2 : 1;
299 /* XXX - Incorrect if several '\b' in a row. */
300 width
= (utf_mode
&& is_wide_char(prev_ch
)) ? -2 : -1;
301 else if (!control_char(c
))
306 if (width
== 2 && shift
- shifted
== 1) {
307 /* Should never happen when called by pshift_all(). */
308 attr
[to
] = attr
[from
];
310 * Assume a wide_char will never be the first half of a
311 * combining_char pair, so reset prev_ch in case we're
312 * followed by a '\b'.
314 prev_ch
= linebuf
[to
++] = ' ';
320 /* Adjust width for magic cookies. */
321 prev_attr
= (to
> 0) ? attr
[to
-1] : AT_NORMAL
;
322 next_attr
= (from
+ len
< curr
) ? attr
[from
+ len
] : prev_attr
;
323 if (!is_at_equiv(attr
[from
], prev_attr
) &&
324 !is_at_equiv(attr
[from
], next_attr
))
326 width
+= attr_swidth(attr
[from
]);
327 if (from
+ len
< curr
)
328 width
+= attr_ewidth(attr
[from
]);
329 if (is_at_equiv(prev_attr
, next_attr
))
331 width
+= attr_ewidth(prev_attr
);
332 if (from
+ len
< curr
)
333 width
+= attr_swidth(next_attr
);
337 if (shift
- shifted
< width
)
346 linebuf
[to
] = linebuf
[from
];
347 attr
[to
++] = attr
[from
++];
364 * Return the printing width of the start (enter) sequence
365 * for a given character attribute.
373 a
= apply_at_specials(a
);
375 if (a
& AT_UNDERLINE
)
388 * Return the printing width of the end (exit) sequence
389 * for a given character attribute.
397 a
= apply_at_specials(a
);
399 if (a
& AT_UNDERLINE
)
412 * Return the printing width of a given character and attribute,
413 * if the character were added to the current position in the line buffer.
414 * Adding a character with a given attribute may cause an enter or exit
415 * attribute sequence to be inserted, so this must be taken into account.
418 pwidth(ch
, a
, prev_ch
)
427 * Backspace moves backwards one or two positions.
428 * XXX - Incorrect if several '\b' in a row.
430 return (utf_mode
&& is_wide_char(prev_ch
)) ? -2 : -1;
432 if (!utf_mode
|| is_ascii_char(ch
))
434 if (control_char((char)ch
))
437 * Control characters do unpredictable things,
438 * so we don't even try to guess; say it doesn't move.
439 * This can only happen if the -r flag is in effect.
445 if (is_composing_char(ch
) || is_combining_char(prev_ch
, ch
))
448 * Composing and combining chars take up no space.
450 * Some terminals, upon failure to compose a
451 * composing character with the character(s) that
452 * precede(s) it will actually take up one column
453 * for the composing character; there isn't much
454 * we could do short of testing the (complex)
455 * composition process ourselves and printing
456 * a binary representation when it fails.
463 * Other characters take one or two columns,
464 * plus the width of any attribute enter/exit sequence.
467 if (is_wide_char(ch
))
469 if (curr
> 0 && !is_at_equiv(attr
[curr
-1], a
))
470 w
+= attr_ewidth(attr
[curr
-1]);
471 if ((apply_at_specials(a
) != AT_NORMAL
) &&
472 (curr
== 0 || !is_at_equiv(attr
[curr
-1], a
)))
478 * Delete to the previous base character in the line buffer.
479 * Return 1 if one is found.
485 char *p
= linebuf
+ curr
;
486 LWCHAR ch
= step_char(&p
, -1, linebuf
+ lmargin
);
489 /* This assumes that there is no '\b' in linebuf. */
490 while ( curr
> lmargin
492 && (!(attr
[curr
- 1] & (AT_ANSI
|AT_BINARY
))))
494 curr
= (int) (p
- linebuf
);
495 prev_ch
= step_char(&p
, -1, linebuf
+ lmargin
);
496 width
= pwidth(ch
, attr
[curr
], prev_ch
);
507 * Are we currently within a recognized ANSI escape sequence?
515 * Search backwards for either an ESC (which means we ARE in a seq);
516 * or an end char (which means we're NOT in a seq).
518 for (p
= &linebuf
[curr
]; p
> linebuf
; )
520 LWCHAR ch
= step_char(&p
, -1, linebuf
);
521 if (IS_CSI_START(ch
))
523 if (!is_ansi_middle(ch
))
530 * Is a character the end of an ANSI escape sequence?
536 if (!is_ascii_char(ch
))
538 return (strchr(end_ansi_chars
, (char) ch
) != NULL
);
548 if (!is_ascii_char(ch
))
552 return (strchr(mid_ansi_chars
, (char) ch
) != NULL
);
556 * Append a character and attribute to the line buffer.
558 #define STORE_CHAR(ch,a,rep,pos) \
560 if (store_char((ch),(a),(rep),(pos))) return (1); \
564 store_char(ch
, a
, rep
, pos
)
574 w
= (a
& (AT_UNDERLINE
|AT_BOLD
)); /* Pre-use w. */
581 if (is_hilited(pos
, pos
+1, 0, &matches
))
584 * This character should be highlighted.
585 * Override the attribute passed in.
589 if (highest_hilite
!= NULL_POSITION
&&
590 pos
> highest_hilite
)
591 highest_hilite
= pos
;
598 if (ctldisp
== OPT_ONPLUS
&& in_ansi_esc_seq())
600 if (!is_ansi_end(ch
) && !is_ansi_middle(ch
)) {
601 /* Remove whole unrecognized sequence. */
602 char *p
= &linebuf
[curr
];
605 bch
= step_char(&p
, -1, linebuf
);
606 } while (p
> linebuf
&& !IS_CSI_START(bch
));
607 curr
= (int) (p
- linebuf
);
610 a
= AT_ANSI
; /* Will force re-AT_'ing around it. */
613 else if (ctldisp
== OPT_ONPLUS
&& IS_CSI_START(ch
))
615 a
= AT_ANSI
; /* Will force re-AT_'ing around it. */
620 char *p
= &linebuf
[curr
];
621 LWCHAR prev_ch
= step_char(&p
, -1, linebuf
);
622 w
= pwidth(ch
, a
, prev_ch
);
625 if (ctldisp
!= OPT_ON
&& column
+ w
+ attr_ewidth(a
) > sc_width
)
627 * Won't fit on screen.
638 replen
= utf_len(rep
[0]);
640 if (curr
+ replen
>= size_linebuf
-6)
643 * Won't fit in line buffer.
646 if (expand_linebuf())
652 linebuf
[curr
] = *rep
++;
661 * Append a tab to the line buffer.
662 * Store spaces to represent the tab.
664 #define STORE_TAB(a,pos) \
665 do { if (store_tab((a),(pos))) return (1); } while (0)
672 int to_tab
= column
+ cshift
- lmargin
;
675 if (ntabstops
< 2 || to_tab
>= tabstops
[ntabstops
-1])
676 to_tab
= tabdefault
-
677 ((to_tab
- tabstops
[ntabstops
-1]) % tabdefault
);
680 for (i
= ntabstops
- 2; i
>= 0; i
--)
681 if (to_tab
>= tabstops
[i
])
683 to_tab
= tabstops
[i
+1] - to_tab
;
686 if (column
+ to_tab
- 1 + pwidth(' ', attr
, 0) + attr_ewidth(attr
) > sc_width
)
690 STORE_CHAR(' ', attr
, " ", pos
);
691 } while (--to_tab
> 0);
695 #define STORE_PRCHAR(c, pos) \
696 do { if (store_prchar((c), (pos))) return 1; } while (0)
706 * Convert to printable representation.
711 * Make sure we can get the entire representation
712 * of the character on this line.
714 if (column
+ (int) strlen(s
) - 1 +
715 pwidth(' ', binattr
, 0) + attr_ewidth(binattr
) > sc_width
)
718 for ( ; *s
!= 0; s
++)
719 STORE_CHAR(*s
, AT_BINARY
, NULL
, pos
);
730 for (i
= 0; i
< mbc_buf_index
; i
++)
731 if (store_prchar(mbc_buf
[i
], pos
))
732 return mbc_buf_index
- i
;
738 * Append a character to the line buffer.
739 * Expand tabs into spaces, handle underlining, boldfacing, etc.
740 * Returns 0 if ok, 1 if couldn't fit in buffer.
751 if (c
== '\r' && pendc
== '\r')
753 if (do_append(pendc
, NULL
, pendpos
))
755 * Oops. We've probably lost the char which
756 * was in pendc, since caller won't back up.
762 if (c
== '\r' && bs_mode
== BS_SPECIAL
)
764 if (mbc_buf_len
> 0) /* utf_mode must be on. */
766 /* Flush incomplete (truncated) sequence. */
767 r
= flush_mbc_buf(mbc_pos
);
768 mbc_buf_index
= r
+ 1;
771 return (mbc_buf_index
);
775 * Don't put the CR into the buffer until we see
776 * the next char. If the next char is a newline,
786 r
= do_append(c
, NULL
, pos
);
789 /* Perform strict validation in all possible cases. */
790 if (mbc_buf_len
== 0)
795 if (IS_ASCII_OCTET(c
))
796 r
= do_append(c
, NULL
, pos
);
797 else if (IS_UTF8_LEAD(c
))
799 mbc_buf_len
= utf_len(c
);
803 /* UTF8_INVALID or stray UTF8_TRAIL */
804 r
= flush_mbc_buf(pos
);
805 } else if (IS_UTF8_TRAIL(c
))
807 mbc_buf
[mbc_buf_index
++] = c
;
808 if (mbc_buf_index
< mbc_buf_len
)
810 if (is_utf8_well_formed(mbc_buf
))
811 r
= do_append(get_wchar(mbc_buf
), mbc_buf
, mbc_pos
);
813 /* Complete, but not shortest form, sequence. */
814 mbc_buf_index
= r
= flush_mbc_buf(mbc_pos
);
818 /* Flush incomplete (truncated) sequence. */
819 r
= flush_mbc_buf(mbc_pos
);
820 mbc_buf_index
= r
+ 1;
822 /* Handle new char. */
829 * If we need to shift the line, do it.
830 * But wait until we get to at least the middle of the screen,
831 * so shifting it doesn't affect the chars we're currently
832 * pappending. (Bold & underline can get messed up otherwise.)
834 if (cshift
< hshift
&& column
> sc_width
/ 2)
836 linebuf
[curr
] = '\0';
837 pshift(hshift
- cshift
);
841 /* How many chars should caller back up? */
842 r
= (!utf_mode
) ? 1 : mbc_buf_index
;
848 do_append(ch
, rep
, pos
)
860 if (bs_mode
== BS_CONTROL
)
861 goto do_control_char
;
864 * A better test is needed here so we don't
865 * backspace over part of the printed
866 * representation of a binary character.
870 || (attr
[curr
- 1] & (AT_ANSI
|AT_BINARY
)))
871 STORE_PRCHAR('\b', pos
);
872 else if (bs_mode
== BS_NORMAL
)
873 STORE_CHAR(ch
, AT_NORMAL
, NULL
, pos
);
874 else if (bs_mode
== BS_SPECIAL
)
875 overstrike
= backc();
883 * Overstrike the character at the current position
884 * in the line buffer. This will cause either
885 * underline (if a "_" is overstruck),
886 * bold (if an identical character is overstruck),
887 * or just deletion of the character in the buffer.
889 overstrike
= utf_mode
? -1 : 0;
892 /* To be correct, this must be a base character. */
893 prev_ch
= get_wchar(linebuf
+ curr
);
896 prev_ch
= (unsigned char) linebuf
[curr
];
902 * Overstriking a char with itself means make it bold.
903 * But overstriking an underscore with itself is
904 * ambiguous. It could mean make it bold, or
905 * it could mean make it underlined.
906 * Use the previous overstrike to resolve it.
910 if ((a
& (AT_BOLD
|AT_UNDERLINE
)) != AT_NORMAL
)
911 a
|= (AT_BOLD
|AT_UNDERLINE
);
912 else if (last_overstrike
!= AT_NORMAL
)
913 a
|= last_overstrike
;
918 } else if (ch
== '_')
922 rep
= linebuf
+ curr
;
923 } else if (prev_ch
== '_')
927 /* Else we replace prev_ch, but we keep its attributes. */
928 } else if (overstrike
< 0)
930 if ( is_composing_char(ch
)
931 || is_combining_char(get_wchar(linebuf
+ curr
), ch
))
932 /* Continuation of the same overstrike. */
941 * Expand a tab into spaces.
946 goto do_control_char
;
952 } else if ((!utf_mode
|| is_ascii_char(ch
)) && control_char((char)ch
))
955 if (ctldisp
== OPT_ON
|| (ctldisp
== OPT_ONPLUS
&& IS_CSI_START(ch
)))
958 * Output as a normal character.
960 STORE_CHAR(ch
, AT_NORMAL
, rep
, pos
);
963 STORE_PRCHAR((char) ch
, pos
);
965 } else if (utf_mode
&& ctldisp
!= OPT_ON
&& is_ubin_char(ch
))
971 if (column
+ (int) strlen(s
) - 1 +
972 pwidth(' ', binattr
, 0) + attr_ewidth(binattr
) > sc_width
)
975 for ( ; *s
!= 0; s
++)
976 STORE_CHAR(*s
, AT_BINARY
, NULL
, pos
);
979 STORE_CHAR(ch
, a
, rep
, pos
);
994 /* Flush incomplete (truncated) sequence. */
995 r
= flush_mbc_buf(mbc_pos
);
1002 * Terminate the line in the line buffer.
1005 pdone(endline
, forw
)
1011 if (pendc
&& (pendc
!= '\r' || !endline
))
1013 * If we had a pending character, put it in the buffer.
1014 * But discard a pending CR if we are at end of line
1015 * (that is, discard the CR in a CR/LF sequence).
1017 (void) do_append(pendc
, NULL
, pendpos
);
1020 * Make sure we've shifted the line, if we need to.
1022 if (cshift
< hshift
)
1023 pshift(hshift
- cshift
);
1025 if (ctldisp
== OPT_ONPLUS
&& is_ansi_end('m'))
1027 /* Switch to normal attribute at end of line. */
1029 for ( ; *p
!= '\0'; p
++)
1032 attr
[curr
++] = AT_ANSI
;
1037 * Add a newline if necessary,
1038 * and append a '\0' to the end of the line.
1039 * We output a newline if we're not at the right edge of the screen,
1040 * or if the terminal doesn't auto wrap,
1041 * or if this is really the end of the line AND the terminal ignores
1042 * a newline at the right edge.
1043 * (In the last case we don't want to output a newline if the terminal
1044 * doesn't ignore it since that would produce an extra blank line.
1045 * But we do want to output a newline if the terminal ignores it in case
1046 * the next line is blank. In that case the single newline output for
1047 * that blank line would be ignored!)
1049 if (column
< sc_width
|| !auto_wrap
|| (endline
&& ignaw
) || ctldisp
== OPT_ON
)
1051 linebuf
[curr
] = '\n';
1052 attr
[curr
] = AT_NORMAL
;
1055 else if (ignaw
&& column
>= sc_width
&& forw
)
1058 * Terminals with "ignaw" don't wrap until they *really* need
1059 * to, i.e. when the character *after* the last one to fit on a
1060 * line is output. But they are too hard to deal with when they
1061 * get in the state where a full screen width of characters
1062 * have been output but the cursor is sitting on the right edge
1063 * instead of at the start of the next line.
1064 * So we nudge them into wrapping by outputting a space
1065 * character plus a backspace. But do this only if moving
1066 * forward; if we're moving backward and drawing this line at
1067 * the top of the screen, the space would overwrite the first
1068 * char on the next line. We don't need to do this "nudge"
1069 * at the top of the screen anyway.
1071 linebuf
[curr
] = ' ';
1072 attr
[curr
++] = AT_NORMAL
;
1073 linebuf
[curr
] = '\b';
1074 attr
[curr
++] = AT_NORMAL
;
1076 linebuf
[curr
] = '\0';
1077 attr
[curr
] = AT_NORMAL
;
1088 attr
[0] = AT_NORMAL
|AT_HILITE
;
1092 * Get a character from the current line.
1093 * Return the character as the function return value,
1094 * and the character attribute in *ap.
1104 * If there is no current line, we pretend the line is
1105 * either "~" or "", depending on the "twiddle" flag.
1116 /* Make sure we're back to AT_NORMAL before the '\n'. */
1118 return i
? '\0' : '\n';
1122 return (linebuf
[i
] & 0xFF);
1126 * Indicate that there is no current line.
1136 * Analogous to forw_line(), but deals with "raw lines":
1137 * lines which are not split for screen width.
1138 * {{ This is supposed to be more efficient than forw_line(). }}
1141 forw_raw_line(curr_pos
, linep
, line_lenp
)
1150 if (curr_pos
== NULL_POSITION
|| ch_seek(curr_pos
) ||
1151 (c
= ch_forw_get()) == EOI
)
1152 return (NULL_POSITION
);
1157 if (c
== '\n' || c
== EOI
|| ABORT_SIGS())
1159 new_pos
= ch_tell();
1162 if (n
>= size_linebuf
-1)
1164 if (expand_linebuf())
1167 * Overflowed the input buffer.
1168 * Pretend the line ended here.
1170 new_pos
= ch_tell() - 1;
1180 if (line_lenp
!= NULL
)
1186 * Analogous to back_line(), but deals with "raw lines".
1187 * {{ This is supposed to be more efficient than back_line(). }}
1190 back_raw_line(curr_pos
, linep
, line_lenp
)
1199 if (curr_pos
== NULL_POSITION
|| curr_pos
<= ch_zero() ||
1200 ch_seek(curr_pos
-1))
1201 return (NULL_POSITION
);
1204 linebuf
[--n
] = '\0';
1208 if (c
== '\n' || ABORT_SIGS())
1211 * This is the newline ending the previous line.
1212 * We have hit the beginning of the line.
1214 new_pos
= ch_tell() + 1;
1220 * We have hit the beginning of the file.
1221 * This must be the first line in the file.
1222 * This must, of course, be the beginning of the line.
1224 new_pos
= ch_zero();
1229 int old_size_linebuf
= size_linebuf
;
1232 if (expand_linebuf())
1235 * Overflowed the input buffer.
1236 * Pretend the line ended here.
1238 new_pos
= ch_tell() + 1;
1242 * Shift the data to the end of the new linebuf.
1244 for (fm
= linebuf
+ old_size_linebuf
- 1,
1245 to
= linebuf
+ size_linebuf
- 1;
1246 fm
>= linebuf
; fm
--, to
--)
1248 n
= size_linebuf
- old_size_linebuf
;
1253 *linep
= &linebuf
[n
];
1254 if (line_lenp
!= NULL
)
1255 *line_lenp
= size_linebuf
- 1 - n
;