1 /* Word-wrapping and line-truncating streams
2 Copyright (C) 1997 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles@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 Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 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 Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* This package emulates glibc `line_wrap_stream' semantics for systems that
34 #include "argp-fmtstream.h"
35 #include "argp-namefrob.h"
37 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
40 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
43 #define INIT_BUF_SIZE 200
44 #define PRINTF_SIZE_GUESS 150
46 /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
47 written on it with LMARGIN spaces and limits them to RMARGIN columns
48 total. If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
49 replacing the whitespace before them with a newline and WMARGIN spaces.
50 Otherwise, chars beyond RMARGIN are simply dropped until a newline.
51 Returns NULL if there was an error. */
53 __argp_make_fmtstream (FILE *stream
,
54 size_t lmargin
, size_t rmargin
, ssize_t wmargin
)
56 argp_fmtstream_t fs
= malloc (sizeof (struct argp_fmtstream
));
61 fs
->lmargin
= lmargin
;
62 fs
->rmargin
= rmargin
;
63 fs
->wmargin
= wmargin
;
67 fs
->buf
= malloc (INIT_BUF_SIZE
);
76 fs
->end
= fs
->buf
+ INIT_BUF_SIZE
;
83 weak_alias (__argp_make_fmtstream
, argp_make_fmtstream
)
86 /* Flush FS to its stream, and free it (but don't close the stream). */
88 __argp_fmtstream_free (argp_fmtstream_t fs
)
90 __argp_fmtstream_update (fs
);
92 fwrite (fs
->buf
, 1, fs
->p
- fs
->buf
, fs
->stream
);
97 weak_alias (__argp_fmtstream_free
, argp_fmtstream_free
)
100 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
101 end of its buffer. This code is mostly from glibc stdio/linewrap.c. */
103 __argp_fmtstream_update (argp_fmtstream_t fs
)
108 /* Scan the buffer for newlines. */
109 buf
= fs
->buf
+ fs
->point_offs
;
114 if (fs
->point_col
== 0 && fs
->lmargin
!= 0)
116 /* We are starting a new line. Print spaces to the left margin. */
117 const size_t pad
= fs
->lmargin
;
118 if (fs
->p
+ pad
< fs
->end
)
120 /* We can fit in them in the buffer by moving the
121 buffer text up and filling in the beginning. */
122 memmove (buf
+ pad
, buf
, fs
->p
- buf
);
123 fs
->p
+= pad
; /* Compensate for bigger buffer. */
124 memset (buf
, ' ', pad
); /* Fill in the spaces. */
125 buf
+= pad
; /* Don't bother searching them. */
129 /* No buffer space for spaces. Must flush. */
131 for (i
= 0; i
< pad
; i
++)
132 putc (' ', fs
->stream
);
138 nl
= memchr (buf
, '\n', len
);
140 if (fs
->point_col
< 0)
145 /* The buffer ends in a partial line. */
147 if (fs
->point_col
+ len
< fs
->rmargin
)
149 /* The remaining buffer text is a partial line and fits
150 within the maximum line width. Advance point for the
151 characters to be written and stop scanning. */
152 fs
->point_col
+= len
;
156 /* Set the end-of-line pointer for the code below to
157 the end of the buffer. */
160 else if (fs
->point_col
+ (nl
- buf
) < (ssize_t
) fs
->rmargin
)
162 /* The buffer contains a full line that fits within the maximum
163 line width. Reset point and scan the next line. */
169 /* This line is too long. */
174 /* Truncate the line by overwriting the excess with the
175 newline and anything after it in the buffer. */
178 memmove (buf
+ (r
- fs
->point_col
), nl
, fs
->p
- nl
);
179 fs
->p
-= buf
+ (r
- fs
->point_col
) - nl
;
180 /* Reset point for the next line and start scanning it. */
182 buf
+= r
+ 1; /* Skip full line plus \n. */
186 /* The buffer ends with a partial line that is beyond the
187 maximum line width. Advance point for the characters
188 written, and discard those past the max from the buffer. */
189 fs
->point_col
+= len
;
190 fs
->p
-= fs
->point_col
- r
;
196 /* Do word wrap. Go to the column just past the maximum line
197 width and scan back for the beginning of the word there.
198 Then insert a line break. */
203 p
= buf
+ (r
+ 1 - fs
->point_col
);
204 while (p
>= buf
&& !isblank (*p
))
206 nextline
= p
+ 1; /* This will begin the next line. */
210 /* Swallow separating blanks. */
214 while (p
> buf
&& isblank (*p
));
215 nl
= p
+ 1; /* The newline will replace the first blank. */
219 /* A single word that is greater than the maximum line width.
220 Oh well. Put it on an overlong line by itself. */
221 p
= buf
+ (r
+ 1 - fs
->point_col
);
222 /* Find the end of the long word. */
225 while (p
< nl
&& !isblank (*p
));
228 /* It already ends a line. No fussing required. */
233 /* We will move the newline to replace the first blank. */
235 /* Swallow separating blanks. */
238 while (isblank (*p
));
239 /* The next line will start here. */
243 /* Note: There are a bunch of tests below for
244 NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
245 at the end of the buffer, and NEXTLINE is in fact empty (and so
246 we need not be careful to maintain its contents). */
248 if (nextline
== buf
+ len
+ 1
249 ? fs
->end
- nl
< fs
->wmargin
+ 1
250 : nextline
- (nl
+ 1) < fs
->wmargin
)
251 /* The margin needs more blanks than we removed. */
252 if (fs
->end
- fs
->p
> fs
->wmargin
+ 1)
253 /* Make some space for them. */
255 size_t mv
= fs
->p
- nextline
;
256 memmove (nl
+ 1 + fs
->wmargin
, nextline
, mv
);
257 nextline
= nl
+ 1 + fs
->wmargin
;
258 len
= nextline
+ mv
- buf
;
262 /* Output the first line so we can use the space. */
265 fwrite (fs
->buf
, 1, nl
- fs
->buf
, fs
->stream
);
266 putc ('\n', fs
->stream
);
267 len
+= buf
- fs
->buf
;
271 /* We can fit the newline and blanks in before
275 if (nextline
- nl
>= fs
->wmargin
276 || (nextline
== buf
+ len
+ 1 && fs
->end
- nextline
>= fs
->wmargin
))
277 /* Add blanks up to the wrap margin column. */
278 for (i
= 0; i
< fs
->wmargin
; ++i
)
281 for (i
= 0; i
< fs
->wmargin
; ++i
)
282 putc (' ', fs
->stream
);
284 /* Copy the tail of the original buffer into the current buffer
287 memmove (nl
, nextline
, buf
+ len
- nextline
);
288 len
-= nextline
- buf
;
290 /* Continue the scan on the remaining lines in the buffer. */
293 /* Restore bufp to include all the remaining text. */
296 /* Reset the counter of what has been output this line. If wmargin
297 is 0, we want to avoid the lmargin getting added, so we set
298 point_col to a magic value of -1 in that case. */
299 fs
->point_col
= fs
->wmargin
? fs
->wmargin
: -1;
303 /* Remember that we've scanned as far as the end of the buffer. */
304 fs
->point_offs
= fs
->p
- fs
->buf
;
307 /* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
308 growing the buffer, or by flushing it. True is returned iff we succeed. */
310 __argp_fmtstream_ensure (struct argp_fmtstream
*fs
, size_t amount
)
312 if ((size_t) (fs
->end
- fs
->p
) < amount
)
316 /* Flush FS's buffer. */
317 __argp_fmtstream_update (fs
);
319 wrote
= fwrite (fs
->buf
, 1, fs
->p
- fs
->buf
, fs
->stream
);
320 if (wrote
== fs
->p
- fs
->buf
)
328 fs
->point_offs
-= wrote
;
329 memmove (fs
->buf
, fs
->buf
+ wrote
, fs
->p
- fs
->buf
);
333 if ((size_t) (fs
->end
- fs
->buf
) < amount
)
334 /* Gotta grow the buffer. */
336 size_t new_size
= fs
->end
- fs
->buf
+ amount
;
337 char *new_buf
= realloc (fs
->buf
, new_size
);
341 __set_errno (ENOMEM
);
346 fs
->end
= new_buf
+ new_size
;
355 __argp_fmtstream_printf (struct argp_fmtstream
*fs
, const char *fmt
, ...)
358 size_t size_guess
= PRINTF_SIZE_GUESS
; /* How much space to reserve. */
364 if (! __argp_fmtstream_ensure (fs
, size_guess
))
366 size_guess
+= size_guess
;
368 va_start (args
, fmt
);
369 out
= __vsnprintf (fs
->p
, fs
->end
- fs
->p
, fmt
, args
);
379 weak_alias (__argp_fmtstream_printf
, argp_fmtstream_printf
)
382 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */