2 * Copyright (C) 1984-2009 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 about less, or for information on how to
8 * contact the author, see the README file.
13 * Routines to manipulate the "line buffer".
14 * The line buffer holds a line of output as it is being built
15 * in preparation for output to the screen.
21 static char *linebuf
= NULL
; /* Buffer which holds the current output line */
22 static char *attr
= NULL
; /* Extension of linebuf to hold attributes */
23 public int size_linebuf
= 0; /* Size of line buffer (and attr buffer) */
25 static int cshift
; /* Current left-shift of output line buffer */
26 public int hshift
; /* Desired left-shift of output line buffer */
27 public int tabstops
[TABSTOP_MAX
] = { 0 }; /* Custom tabstops */
28 public int ntabstops
= 1; /* Number of tabstops */
29 public int tabdefault
= 8; /* Default repeated tabstops */
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
);
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
))))
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.
593 if (ctldisp
== OPT_ONPLUS
&& in_ansi_esc_seq())
595 if (!is_ansi_end(ch
) && !is_ansi_middle(ch
)) {
596 /* Remove whole unrecognized sequence. */
597 char *p
= &linebuf
[curr
];
600 bch
= step_char(&p
, -1, linebuf
);
601 } while (p
> linebuf
&& !IS_CSI_START(bch
));
605 a
= AT_ANSI
; /* Will force re-AT_'ing around it. */
608 else if (ctldisp
== OPT_ONPLUS
&& IS_CSI_START(ch
))
610 a
= AT_ANSI
; /* Will force re-AT_'ing around it. */
615 char *p
= &linebuf
[curr
];
616 LWCHAR prev_ch
= step_char(&p
, -1, linebuf
);
617 w
= pwidth(ch
, a
, prev_ch
);
620 if (ctldisp
!= OPT_ON
&& column
+ w
+ attr_ewidth(a
) > sc_width
)
622 * Won't fit on screen.
633 replen
= utf_len(rep
[0]);
635 if (curr
+ replen
>= size_linebuf
-6)
638 * Won't fit in line buffer.
641 if (expand_linebuf())
647 linebuf
[curr
] = *rep
++;
656 * Append a tab to the line buffer.
657 * Store spaces to represent the tab.
659 #define STORE_TAB(a,pos) \
660 do { if (store_tab((a),(pos))) return (1); } while (0)
667 int to_tab
= column
+ cshift
- lmargin
;
670 if (ntabstops
< 2 || to_tab
>= tabstops
[ntabstops
-1])
671 to_tab
= tabdefault
-
672 ((to_tab
- tabstops
[ntabstops
-1]) % tabdefault
);
675 for (i
= ntabstops
- 2; i
>= 0; i
--)
676 if (to_tab
>= tabstops
[i
])
678 to_tab
= tabstops
[i
+1] - to_tab
;
681 if (column
+ to_tab
- 1 + pwidth(' ', attr
, 0) + attr_ewidth(attr
) > sc_width
)
685 STORE_CHAR(' ', attr
, " ", pos
);
686 } while (--to_tab
> 0);
690 #define STORE_PRCHAR(c, pos) \
691 do { if (store_prchar((c), (pos))) return 1; } while (0)
701 * Convert to printable representation.
706 * Make sure we can get the entire representation
707 * of the character on this line.
709 if (column
+ (int) strlen(s
) - 1 +
710 pwidth(' ', binattr
, 0) + attr_ewidth(binattr
) > sc_width
)
713 for ( ; *s
!= 0; s
++)
714 STORE_CHAR(*s
, AT_BINARY
, NULL
, pos
);
725 for (i
= 0; i
< mbc_buf_index
; i
++)
726 if (store_prchar(mbc_buf
[i
], pos
))
727 return mbc_buf_index
- i
;
733 * Append a character to the line buffer.
734 * Expand tabs into spaces, handle underlining, boldfacing, etc.
735 * Returns 0 if ok, 1 if couldn't fit in buffer.
746 if (do_append(pendc
, NULL
, pendpos
))
748 * Oops. We've probably lost the char which
749 * was in pendc, since caller won't back up.
755 if (c
== '\r' && bs_mode
== BS_SPECIAL
)
757 if (mbc_buf_len
> 0) /* utf_mode must be on. */
759 /* Flush incomplete (truncated) sequence. */
760 r
= flush_mbc_buf(mbc_pos
);
761 mbc_buf_index
= r
+ 1;
764 return (mbc_buf_index
);
768 * Don't put the CR into the buffer until we see
769 * the next char. If the next char is a newline,
779 r
= do_append((LWCHAR
) c
, NULL
, pos
);
782 /* Perform strict validation in all possible cases. */
783 if (mbc_buf_len
== 0)
788 if (IS_ASCII_OCTET(c
))
789 r
= do_append((LWCHAR
) c
, NULL
, pos
);
790 else if (IS_UTF8_LEAD(c
))
792 mbc_buf_len
= utf_len(c
);
796 /* UTF8_INVALID or stray UTF8_TRAIL */
797 r
= flush_mbc_buf(pos
);
798 } else if (IS_UTF8_TRAIL(c
))
800 mbc_buf
[mbc_buf_index
++] = c
;
801 if (mbc_buf_index
< mbc_buf_len
)
803 if (is_utf8_well_formed(mbc_buf
))
804 r
= do_append(get_wchar(mbc_buf
), mbc_buf
, mbc_pos
);
806 /* Complete, but not shortest form, sequence. */
807 mbc_buf_index
= r
= flush_mbc_buf(mbc_pos
);
811 /* Flush incomplete (truncated) sequence. */
812 r
= flush_mbc_buf(mbc_pos
);
813 mbc_buf_index
= r
+ 1;
815 /* Handle new char. */
822 * If we need to shift the line, do it.
823 * But wait until we get to at least the middle of the screen,
824 * so shifting it doesn't affect the chars we're currently
825 * pappending. (Bold & underline can get messed up otherwise.)
827 if (cshift
< hshift
&& column
> sc_width
/ 2)
829 linebuf
[curr
] = '\0';
830 pshift(hshift
- cshift
);
834 /* How many chars should caller back up? */
835 r
= (!utf_mode
) ? 1 : mbc_buf_index
;
841 do_append(ch
, rep
, pos
)
853 if (bs_mode
== BS_CONTROL
)
854 goto do_control_char
;
857 * A better test is needed here so we don't
858 * backspace over part of the printed
859 * representation of a binary character.
863 || (attr
[curr
- 1] & (AT_ANSI
|AT_BINARY
)))
864 STORE_PRCHAR('\b', pos
);
865 else if (bs_mode
== BS_NORMAL
)
866 STORE_CHAR(ch
, AT_NORMAL
, NULL
, pos
);
867 else if (bs_mode
== BS_SPECIAL
)
868 overstrike
= backc();
876 * Overstrike the character at the current position
877 * in the line buffer. This will cause either
878 * underline (if a "_" is overstruck),
879 * bold (if an identical character is overstruck),
880 * or just deletion of the character in the buffer.
882 overstrike
= utf_mode
? -1 : 0;
883 /* To be correct, this must be a base character. */
884 prev_ch
= get_wchar(linebuf
+ curr
);
889 * Overstriking a char with itself means make it bold.
890 * But overstriking an underscore with itself is
891 * ambiguous. It could mean make it bold, or
892 * it could mean make it underlined.
893 * Use the previous overstrike to resolve it.
897 if ((a
& (AT_BOLD
|AT_UNDERLINE
)) != AT_NORMAL
)
898 a
|= (AT_BOLD
|AT_UNDERLINE
);
899 else if (last_overstrike
!= AT_NORMAL
)
900 a
|= last_overstrike
;
905 } else if (ch
== '_')
909 rep
= linebuf
+ curr
;
910 } else if (prev_ch
== '_')
914 /* Else we replace prev_ch, but we keep its attributes. */
915 } else if (overstrike
< 0)
917 if ( is_composing_char(ch
)
918 || is_combining_char(get_wchar(linebuf
+ curr
), ch
))
919 /* Continuation of the same overstrike. */
928 * Expand a tab into spaces.
933 goto do_control_char
;
939 } else if ((!utf_mode
|| is_ascii_char(ch
)) && control_char((char)ch
))
942 if (ctldisp
== OPT_ON
|| (ctldisp
== OPT_ONPLUS
&& IS_CSI_START(ch
)))
945 * Output as a normal character.
947 STORE_CHAR(ch
, AT_NORMAL
, rep
, pos
);
950 STORE_PRCHAR((char) ch
, pos
);
952 } else if (utf_mode
&& ctldisp
!= OPT_ON
&& is_ubin_char(ch
))
958 if (column
+ (int) strlen(s
) - 1 +
959 pwidth(' ', binattr
, 0) + attr_ewidth(binattr
) > sc_width
)
962 for ( ; *s
!= 0; s
++)
963 STORE_CHAR(*s
, AT_BINARY
, NULL
, pos
);
966 STORE_CHAR(ch
, a
, rep
, pos
);
981 /* Flush incomplete (truncated) sequence. */
982 r
= flush_mbc_buf(mbc_pos
);
989 * Terminate the line in the line buffer.
998 if (pendc
&& (pendc
!= '\r' || !endline
))
1000 * If we had a pending character, put it in the buffer.
1001 * But discard a pending CR if we are at end of line
1002 * (that is, discard the CR in a CR/LF sequence).
1004 (void) do_append(pendc
, NULL
, pendpos
);
1007 * Make sure we've shifted the line, if we need to.
1009 if (cshift
< hshift
)
1010 pshift(hshift
- cshift
);
1012 if (ctldisp
== OPT_ONPLUS
&& is_ansi_end('m'))
1014 /* Switch to normal attribute at end of line. */
1016 for ( ; *p
!= '\0'; p
++)
1019 attr
[curr
++] = AT_ANSI
;
1024 * Add a newline if necessary,
1025 * and append a '\0' to the end of the line.
1026 * We output a newline if we're not at the right edge of the screen,
1027 * or if the terminal doesn't auto wrap,
1028 * or if this is really the end of the line AND the terminal ignores
1029 * a newline at the right edge.
1030 * (In the last case we don't want to output a newline if the terminal
1031 * doesn't ignore it since that would produce an extra blank line.
1032 * But we do want to output a newline if the terminal ignores it in case
1033 * the next line is blank. In that case the single newline output for
1034 * that blank line would be ignored!)
1036 if (column
< sc_width
|| !auto_wrap
|| (endline
&& ignaw
) || ctldisp
== OPT_ON
)
1038 linebuf
[curr
] = '\n';
1039 attr
[curr
] = AT_NORMAL
;
1042 else if (ignaw
&& column
>= sc_width
&& forw
)
1045 * Terminals with "ignaw" don't wrap until they *really* need
1046 * to, i.e. when the character *after* the last one to fit on a
1047 * line is output. But they are too hard to deal with when they
1048 * get in the state where a full screen width of characters
1049 * have been output but the cursor is sitting on the right edge
1050 * instead of at the start of the next line.
1051 * So we nudge them into wrapping by outputting a space
1052 * character plus a backspace. But do this only if moving
1053 * forward; if we're moving backward and drawing this line at
1054 * the top of the screen, the space would overwrite the first
1055 * char on the next line. We don't need to do this "nudge"
1056 * at the top of the screen anyway.
1058 linebuf
[curr
] = ' ';
1059 attr
[curr
++] = AT_NORMAL
;
1060 linebuf
[curr
] = '\b';
1061 attr
[curr
++] = AT_NORMAL
;
1063 linebuf
[curr
] = '\0';
1064 attr
[curr
] = AT_NORMAL
;
1075 attr
[0] = AT_NORMAL
|AT_HILITE
;
1079 * Get a character from the current line.
1080 * Return the character as the function return value,
1081 * and the character attribute in *ap.
1091 * If there is no current line, we pretend the line is
1092 * either "~" or "", depending on the "twiddle" flag.
1103 /* Make sure we're back to AT_NORMAL before the '\n'. */
1105 return i
? '\0' : '\n';
1109 return (linebuf
[i
] & 0xFF);
1113 * Indicate that there is no current line.
1123 * Analogous to forw_line(), but deals with "raw lines":
1124 * lines which are not split for screen width.
1125 * {{ This is supposed to be more efficient than forw_line(). }}
1128 forw_raw_line(curr_pos
, linep
, line_lenp
)
1137 if (curr_pos
== NULL_POSITION
|| ch_seek(curr_pos
) ||
1138 (c
= ch_forw_get()) == EOI
)
1139 return (NULL_POSITION
);
1144 if (c
== '\n' || c
== EOI
|| ABORT_SIGS())
1146 new_pos
= ch_tell();
1149 if (n
>= size_linebuf
-1)
1151 if (expand_linebuf())
1154 * Overflowed the input buffer.
1155 * Pretend the line ended here.
1157 new_pos
= ch_tell() - 1;
1167 if (line_lenp
!= NULL
)
1173 * Analogous to back_line(), but deals with "raw lines".
1174 * {{ This is supposed to be more efficient than back_line(). }}
1177 back_raw_line(curr_pos
, linep
, line_lenp
)
1186 if (curr_pos
== NULL_POSITION
|| curr_pos
<= ch_zero() ||
1187 ch_seek(curr_pos
-1))
1188 return (NULL_POSITION
);
1191 linebuf
[--n
] = '\0';
1195 if (c
== '\n' || ABORT_SIGS())
1198 * This is the newline ending the previous line.
1199 * We have hit the beginning of the line.
1201 new_pos
= ch_tell() + 1;
1207 * We have hit the beginning of the file.
1208 * This must be the first line in the file.
1209 * This must, of course, be the beginning of the line.
1211 new_pos
= ch_zero();
1216 int old_size_linebuf
= size_linebuf
;
1219 if (expand_linebuf())
1222 * Overflowed the input buffer.
1223 * Pretend the line ended here.
1225 new_pos
= ch_tell() + 1;
1229 * Shift the data to the end of the new linebuf.
1231 for (fm
= linebuf
+ old_size_linebuf
- 1,
1232 to
= linebuf
+ size_linebuf
- 1;
1233 fm
>= linebuf
; fm
--, to
--)
1235 n
= size_linebuf
- old_size_linebuf
;
1240 *linep
= &linebuf
[n
];
1241 if (line_lenp
!= NULL
)
1242 *line_lenp
= size_linebuf
- 1 - n
;