Update.
[glibc.git] / argp / argp-fmtstream.c
blob215160bdcd430c6fdaeedc698eb22ffc7d76d665
1 /* Word-wrapping and line-truncating streams
2 Copyright (C) 1997,1998,1999,2001,2002,2003 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 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; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
21 /* This package emulates glibc `line_wrap_stream' semantics for systems that
22 don't have that. */
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <stdarg.h>
32 #include <ctype.h>
34 #include "argp-fmtstream.h"
35 #include "argp-namefrob.h"
37 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
39 #ifndef isblank
40 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
41 #endif
43 #if defined _LIBC && defined USE_IN_LIBIO
44 # include <wchar.h>
45 # include <libio/libioP.h>
46 # define __vsnprintf(s, l, f, a) _IO_vsnprintf (s, l, f, a)
47 #endif
49 #define INIT_BUF_SIZE 200
50 #define PRINTF_SIZE_GUESS 150
52 /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
53 written on it with LMARGIN spaces and limits them to RMARGIN columns
54 total. If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
55 replacing the whitespace before them with a newline and WMARGIN spaces.
56 Otherwise, chars beyond RMARGIN are simply dropped until a newline.
57 Returns NULL if there was an error. */
58 argp_fmtstream_t
59 __argp_make_fmtstream (FILE *stream,
60 size_t lmargin, size_t rmargin, ssize_t wmargin)
62 argp_fmtstream_t fs;
64 fs = (struct argp_fmtstream *) malloc (sizeof (struct argp_fmtstream));
65 if (fs != NULL)
67 fs->stream = stream;
69 fs->lmargin = lmargin;
70 fs->rmargin = rmargin;
71 fs->wmargin = wmargin;
72 fs->point_col = 0;
73 fs->point_offs = 0;
75 fs->buf = (char *) malloc (INIT_BUF_SIZE);
76 if (! fs->buf)
78 free (fs);
79 fs = 0;
81 else
83 fs->p = fs->buf;
84 fs->end = fs->buf + INIT_BUF_SIZE;
88 return fs;
90 #if 0
91 /* Not exported. */
92 #ifdef weak_alias
93 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
94 #endif
95 #endif
97 /* Flush FS to its stream, and free it (but don't close the stream). */
98 void
99 __argp_fmtstream_free (argp_fmtstream_t fs)
101 __argp_fmtstream_update (fs);
102 if (fs->p > fs->buf)
104 #ifdef USE_IN_LIBIO
105 if (_IO_fwide (fs->stream, 0) > 0)
106 __fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
107 else
108 #endif
109 fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
111 free (fs->buf);
112 free (fs);
114 #if 0
115 /* Not exported. */
116 #ifdef weak_alias
117 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
118 #endif
119 #endif
121 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
122 end of its buffer. This code is mostly from glibc stdio/linewrap.c. */
123 void
124 __argp_fmtstream_update (argp_fmtstream_t fs)
126 char *buf, *nl;
127 size_t len;
129 /* Scan the buffer for newlines. */
130 buf = fs->buf + fs->point_offs;
131 while (buf < fs->p)
133 size_t r;
135 if (fs->point_col == 0 && fs->lmargin != 0)
137 /* We are starting a new line. Print spaces to the left margin. */
138 const size_t pad = fs->lmargin;
139 if (fs->p + pad < fs->end)
141 /* We can fit in them in the buffer by moving the
142 buffer text up and filling in the beginning. */
143 memmove (buf + pad, buf, fs->p - buf);
144 fs->p += pad; /* Compensate for bigger buffer. */
145 memset (buf, ' ', pad); /* Fill in the spaces. */
146 buf += pad; /* Don't bother searching them. */
148 else
150 /* No buffer space for spaces. Must flush. */
151 size_t i;
152 for (i = 0; i < pad; i++)
154 #ifdef USE_IN_LIBIO
155 if (_IO_fwide (fs->stream, 0) > 0)
156 putwc_unlocked (L' ', fs->stream);
157 else
158 #endif
159 putc_unlocked (' ', fs->stream);
162 fs->point_col = pad;
165 len = fs->p - buf;
166 nl = memchr (buf, '\n', len);
168 if (fs->point_col < 0)
169 fs->point_col = 0;
171 if (!nl)
173 /* The buffer ends in a partial line. */
175 if (fs->point_col + len < fs->rmargin)
177 /* The remaining buffer text is a partial line and fits
178 within the maximum line width. Advance point for the
179 characters to be written and stop scanning. */
180 fs->point_col += len;
181 break;
183 else
184 /* Set the end-of-line pointer for the code below to
185 the end of the buffer. */
186 nl = fs->p;
188 else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
190 /* The buffer contains a full line that fits within the maximum
191 line width. Reset point and scan the next line. */
192 fs->point_col = 0;
193 buf = nl + 1;
194 continue;
197 /* This line is too long. */
198 r = fs->rmargin - 1;
200 if (fs->wmargin < 0)
202 /* Truncate the line by overwriting the excess with the
203 newline and anything after it in the buffer. */
204 if (nl < fs->p)
206 memmove (buf + (r - fs->point_col), nl, fs->p - nl);
207 fs->p -= buf + (r - fs->point_col) - nl;
208 /* Reset point for the next line and start scanning it. */
209 fs->point_col = 0;
210 buf += r + 1; /* Skip full line plus \n. */
212 else
214 /* The buffer ends with a partial line that is beyond the
215 maximum line width. Advance point for the characters
216 written, and discard those past the max from the buffer. */
217 fs->point_col += len;
218 fs->p -= fs->point_col - r;
219 break;
222 else
224 /* Do word wrap. Go to the column just past the maximum line
225 width and scan back for the beginning of the word there.
226 Then insert a line break. */
228 char *p, *nextline;
229 int i;
231 p = buf + (r + 1 - fs->point_col);
232 while (p >= buf && !isblank (*p))
233 --p;
234 nextline = p + 1; /* This will begin the next line. */
236 if (nextline > buf)
238 /* Swallow separating blanks. */
239 if (p >= buf)
241 --p;
242 while (p >= buf && isblank (*p));
243 nl = p + 1; /* The newline will replace the first blank. */
245 else
247 /* A single word that is greater than the maximum line width.
248 Oh well. Put it on an overlong line by itself. */
249 p = buf + (r + 1 - fs->point_col);
250 /* Find the end of the long word. */
252 ++p;
253 while (p < nl && !isblank (*p));
254 if (p == nl)
256 /* It already ends a line. No fussing required. */
257 fs->point_col = 0;
258 buf = nl + 1;
259 continue;
261 /* We will move the newline to replace the first blank. */
262 nl = p;
263 /* Swallow separating blanks. */
265 ++p;
266 while (isblank (*p));
267 /* The next line will start here. */
268 nextline = p;
271 /* Note: There are a bunch of tests below for
272 NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
273 at the end of the buffer, and NEXTLINE is in fact empty (and so
274 we need not be careful to maintain its contents). */
276 if ((nextline == buf + len + 1
277 ? fs->end - nl < fs->wmargin + 1
278 : nextline - (nl + 1) < fs->wmargin)
279 && fs->p > nextline)
281 /* The margin needs more blanks than we removed. */
282 if (fs->end - fs->p > fs->wmargin + 1)
283 /* Make some space for them. */
285 size_t mv = fs->p - nextline;
286 memmove (nl + 1 + fs->wmargin, nextline, mv);
287 nextline = nl + 1 + fs->wmargin;
288 len = nextline + mv - buf;
289 *nl++ = '\n';
291 else
292 /* Output the first line so we can use the space. */
294 #ifdef USE_IN_LIBIO
295 if (_IO_fwide (fs->stream, 0) > 0)
296 __fwprintf (fs->stream, L"%.*s\n",
297 (int) (nl - fs->buf), fs->buf);
298 else
299 #endif
301 if (nl > fs->buf)
302 fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
303 putc_unlocked ('\n', fs->stream);
305 len += buf - fs->buf;
306 nl = buf = fs->buf;
309 else
310 /* We can fit the newline and blanks in before
311 the next word. */
312 *nl++ = '\n';
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)
318 *nl++ = ' ';
319 else
320 for (i = 0; i < fs->wmargin; ++i)
321 #ifdef USE_IN_LIBIO
322 if (_IO_fwide (fs->stream, 0) > 0)
323 putwc_unlocked (L' ', fs->stream);
324 else
325 #endif
326 putc_unlocked (' ', fs->stream);
328 /* Copy the tail of the original buffer into the current buffer
329 position. */
330 if (nl < nextline)
331 memmove (nl, nextline, buf + len - nextline);
332 len -= nextline - buf;
334 /* Continue the scan on the remaining lines in the buffer. */
335 buf = nl;
337 /* Restore bufp to include all the remaining text. */
338 fs->p = nl + len;
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)
358 ssize_t wrote;
360 /* Flush FS's buffer. */
361 __argp_fmtstream_update (fs);
363 #ifdef USE_IN_LIBIO
364 if (_IO_fwide (fs->stream, 0) > 0)
366 __fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
367 wrote = fs->p - fs->buf;
369 else
370 #endif
371 wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
372 if (wrote == fs->p - fs->buf)
374 fs->p = fs->buf;
375 fs->point_offs = 0;
377 else
379 fs->p -= wrote;
380 fs->point_offs -= wrote;
381 memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
382 return 0;
385 if ((size_t) (fs->end - fs->buf) < amount)
386 /* Gotta grow the buffer. */
388 size_t old_size = fs->end - fs->buf;
389 size_t new_size = old_size + amount;
390 char *new_buf;
392 if (new_size < old_size || ! (new_buf = realloc (fs->buf, new_size)))
394 __set_errno (ENOMEM);
395 return 0;
398 fs->buf = new_buf;
399 fs->end = new_buf + new_size;
400 fs->p = fs->buf;
404 return 1;
407 ssize_t
408 __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
410 int out;
411 size_t avail;
412 size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
416 va_list args;
418 if (! __argp_fmtstream_ensure (fs, size_guess))
419 return -1;
421 va_start (args, fmt);
422 avail = fs->end - fs->p;
423 out = __vsnprintf (fs->p, avail, fmt, args);
424 va_end (args);
425 if ((size_t) out >= avail)
426 size_guess = out + 1;
428 while ((size_t) out >= avail);
430 fs->p += out;
432 return out;
434 #if 0
435 /* Not exported. */
436 #ifdef weak_alias
437 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
438 #endif
439 #endif
441 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */