1 /* Word-wrapping and line-truncating streams
2 Copyright (C) 1997-1999,2001,2002,2003,2005 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles at gnu.ai.mit.edu>.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If
18 not, see <http://www.gnu.org/licenses/>.
20 Modified for uClibc by: Salvatore Cro <salvatore.cro at st.com>
23 /* This package emulates glibc `line_wrap_stream' semantics for systems that
36 #include "argp-fmtstream.h"
38 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
41 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
44 #if defined _LIBC && defined USE_IN_LIBIO
46 # include <libio/libioP.h>
47 # define __vsnprintf(s, l, f, a) _IO_vsnprintf (s, l, f, a)
49 # define __vsnprintf(s, l, f, a) vsnprintf (s, l, f, a)
52 #define INIT_BUF_SIZE 200
53 #define PRINTF_SIZE_GUESS 150
55 /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
56 written on it with LMARGIN spaces and limits them to RMARGIN columns
57 total. If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
58 replacing the whitespace before them with a newline and WMARGIN spaces.
59 Otherwise, chars beyond RMARGIN are simply dropped until a newline.
60 Returns NULL if there was an error. */
62 __argp_make_fmtstream (FILE *stream
,
63 size_t lmargin
, size_t rmargin
, ssize_t wmargin
)
67 fs
= (struct argp_fmtstream
*) malloc (sizeof (struct argp_fmtstream
));
72 fs
->lmargin
= lmargin
;
73 fs
->rmargin
= rmargin
;
74 fs
->wmargin
= wmargin
;
78 fs
->buf
= (char *) malloc (INIT_BUF_SIZE
);
87 fs
->end
= fs
->buf
+ INIT_BUF_SIZE
;
96 weak_alias (__argp_make_fmtstream
, argp_make_fmtstream
)
100 /* Flush FS to its stream, and free it (but don't close the stream). */
102 __argp_fmtstream_free (argp_fmtstream_t fs
)
104 __argp_fmtstream_update (fs
);
108 __fxprintf (fs
->stream
, "%.*s", (int) (fs
->p
- fs
->buf
), fs
->buf
);
110 fwrite_unlocked (fs
->buf
, 1, fs
->p
- fs
->buf
, fs
->stream
);
119 weak_alias (__argp_fmtstream_free
, argp_fmtstream_free
)
123 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
124 end of its buffer. This code is mostly from glibc stdio/linewrap.c. */
126 __argp_fmtstream_update (argp_fmtstream_t fs
)
131 /* Scan the buffer for newlines. */
132 buf
= fs
->buf
+ fs
->point_offs
;
137 if (fs
->point_col
== 0 && fs
->lmargin
!= 0)
139 /* We are starting a new line. Print spaces to the left margin. */
140 const size_t pad
= fs
->lmargin
;
141 if (fs
->p
+ pad
< fs
->end
)
143 /* We can fit in them in the buffer by moving the
144 buffer text up and filling in the beginning. */
145 memmove (buf
+ pad
, buf
, fs
->p
- buf
);
146 fs
->p
+= pad
; /* Compensate for bigger buffer. */
147 memset (buf
, ' ', pad
); /* Fill in the spaces. */
148 buf
+= pad
; /* Don't bother searching them. */
152 /* No buffer space for spaces. Must flush. */
154 for (i
= 0; i
< pad
; i
++)
157 if (_IO_fwide (fs
->stream
, 0) > 0)
158 putwc_unlocked (L
' ', fs
->stream
);
161 putc_unlocked (' ', fs
->stream
);
168 nl
= memchr (buf
, '\n', len
);
170 if (fs
->point_col
< 0)
175 /* The buffer ends in a partial line. */
177 if (fs
->point_col
+ len
< fs
->rmargin
)
179 /* The remaining buffer text is a partial line and fits
180 within the maximum line width. Advance point for the
181 characters to be written and stop scanning. */
182 fs
->point_col
+= len
;
186 /* Set the end-of-line pointer for the code below to
187 the end of the buffer. */
190 else if (fs
->point_col
+ (nl
- buf
) < (ssize_t
) fs
->rmargin
)
192 /* The buffer contains a full line that fits within the maximum
193 line width. Reset point and scan the next line. */
199 /* This line is too long. */
204 /* Truncate the line by overwriting the excess with the
205 newline and anything after it in the buffer. */
208 memmove (buf
+ (r
- fs
->point_col
), nl
, fs
->p
- nl
);
209 fs
->p
-= buf
+ (r
- fs
->point_col
) - nl
;
210 /* Reset point for the next line and start scanning it. */
212 buf
+= r
+ 1; /* Skip full line plus \n. */
216 /* The buffer ends with a partial line that is beyond the
217 maximum line width. Advance point for the characters
218 written, and discard those past the max from the buffer. */
219 fs
->point_col
+= len
;
220 fs
->p
-= fs
->point_col
- r
;
226 /* Do word wrap. Go to the column just past the maximum line
227 width and scan back for the beginning of the word there.
228 Then insert a line break. */
233 p
= buf
+ (r
+ 1 - fs
->point_col
);
234 while (p
>= buf
&& !isblank (*p
))
236 nextline
= p
+ 1; /* This will begin the next line. */
240 /* Swallow separating blanks. */
244 while (p
>= buf
&& isblank (*p
));
245 nl
= p
+ 1; /* The newline will replace the first blank. */
249 /* A single word that is greater than the maximum line width.
250 Oh well. Put it on an overlong line by itself. */
251 p
= buf
+ (r
+ 1 - fs
->point_col
);
252 /* Find the end of the long word. */
255 while (p
< nl
&& !isblank (*p
));
258 /* It already ends a line. No fussing required. */
263 /* We will move the newline to replace the first blank. */
265 /* Swallow separating blanks. */
268 while (isblank (*p
));
269 /* The next line will start here. */
273 /* Note: There are a bunch of tests below for
274 NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
275 at the end of the buffer, and NEXTLINE is in fact empty (and so
276 we need not be careful to maintain its contents). */
278 if ((nextline
== buf
+ len
+ 1
279 ? fs
->end
- nl
< fs
->wmargin
+ 1
280 : nextline
- (nl
+ 1) < fs
->wmargin
)
283 /* The margin needs more blanks than we removed. */
284 if (fs
->end
- fs
->p
> fs
->wmargin
+ 1)
285 /* Make some space for them. */
287 size_t mv
= fs
->p
- nextline
;
288 memmove (nl
+ 1 + fs
->wmargin
, nextline
, mv
);
289 nextline
= nl
+ 1 + fs
->wmargin
;
290 len
= nextline
+ mv
- buf
;
294 /* Output the first line so we can use the space. */
296 #if defined _LIBC && defined USE_IN_LIBIO
297 __fxprintf (fs
->stream
, "%.*s\n",
298 (int) (nl
- fs
->buf
), fs
->buf
);
301 fwrite_unlocked (fs
->buf
, 1, nl
- fs
->buf
, fs
->stream
);
302 putc_unlocked ('\n', fs
->stream
);
305 len
+= buf
- fs
->buf
;
310 /* We can fit the newline and blanks in before
314 if (nextline
- nl
>= fs
->wmargin
315 || (nextline
== buf
+ len
+ 1 && fs
->end
- nextline
>= fs
->wmargin
))
316 /* Add blanks up to the wrap margin column. */
317 for (i
= 0; i
< fs
->wmargin
; ++i
)
320 for (i
= 0; i
< fs
->wmargin
; ++i
)
322 if (_IO_fwide (fs
->stream
, 0) > 0)
323 putwc_unlocked (L
' ', fs
->stream
);
326 putc_unlocked (' ', fs
->stream
);
328 /* Copy the tail of the original buffer into the current buffer
331 memmove (nl
, nextline
, buf
+ len
- nextline
);
332 len
-= nextline
- buf
;
334 /* Continue the scan on the remaining lines in the buffer. */
337 /* Restore bufp to include all the remaining text. */
340 /* Reset the counter of what has been output this line. If wmargin
341 is 0, we want to avoid the lmargin getting added, so we set
342 point_col to a magic value of -1 in that case. */
343 fs
->point_col
= fs
->wmargin
? fs
->wmargin
: -1;
347 /* Remember that we've scanned as far as the end of the buffer. */
348 fs
->point_offs
= fs
->p
- fs
->buf
;
351 /* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
352 growing the buffer, or by flushing it. True is returned iff we succeed. */
354 __argp_fmtstream_ensure (struct argp_fmtstream
*fs
, size_t amount
)
356 if ((size_t) (fs
->end
- fs
->p
) < amount
)
360 /* Flush FS's buffer. */
361 __argp_fmtstream_update (fs
);
363 #if defined _LIBC && defined USE_IN_LIBIO
364 __fxprintf (fs
->stream
, "%.*s", (int) (fs
->p
- fs
->buf
), fs
->buf
);
365 wrote
= fs
->p
- fs
->buf
;
367 wrote
= fwrite_unlocked (fs
->buf
, 1, fs
->p
- fs
->buf
, fs
->stream
);
369 if (wrote
== fs
->p
- fs
->buf
)
377 fs
->point_offs
-= wrote
;
378 memmove (fs
->buf
, fs
->buf
+ wrote
, fs
->p
- fs
->buf
);
382 if ((size_t) (fs
->end
- fs
->buf
) < amount
)
383 /* Gotta grow the buffer. */
385 size_t old_size
= fs
->end
- fs
->buf
;
386 size_t new_size
= old_size
+ amount
;
389 if (new_size
< old_size
|| ! (new_buf
= realloc (fs
->buf
, new_size
)))
391 __set_errno (ENOMEM
);
396 fs
->end
= new_buf
+ new_size
;
405 __argp_fmtstream_printf (struct argp_fmtstream
*fs
, const char *fmt
, ...)
409 size_t size_guess
= PRINTF_SIZE_GUESS
; /* How much space to reserve. */
415 if (! __argp_fmtstream_ensure (fs
, size_guess
))
418 va_start (args
, fmt
);
419 avail
= fs
->end
- fs
->p
;
420 out
= __vsnprintf (fs
->p
, avail
, fmt
, args
);
422 if ((size_t) out
>= avail
)
423 size_guess
= out
+ 1;
425 while ((size_t) out
>= avail
);
434 weak_alias (__argp_fmtstream_printf
, argp_fmtstream_printf
)
438 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */