Update to 2.1.x development version
[kopensolaris-gnu/glibc.git] / argp / argp-fmtstream.c
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>.
5
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.
10
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.
15
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.  */
20
21 /* This package emulates glibc `line_wrap_stream' semantics for systems that
22    don't have that.  */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <stdarg.h>
32 #include <ctype.h>
33
34 #include "argp-fmtstream.h"
35 #include "argp-namefrob.h"
36
37 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
38
39 #ifndef isblank
40 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
41 #endif
42
43 #define INIT_BUF_SIZE 200
44 #define PRINTF_SIZE_GUESS 150
45 \f
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.  */
52 argp_fmtstream_t
53 __argp_make_fmtstream (FILE *stream,
54                        size_t lmargin, size_t rmargin, ssize_t wmargin)
55 {
56   argp_fmtstream_t fs = malloc (sizeof (struct argp_fmtstream));
57   if (fs)
58     {
59       fs->stream = stream;
60
61       fs->lmargin = lmargin;
62       fs->rmargin = rmargin;
63       fs->wmargin = wmargin;
64       fs->point_col = 0;
65       fs->point_offs = 0;
66
67       fs->buf = malloc (INIT_BUF_SIZE);
68       if (! fs->buf)
69         {
70           free (fs);
71           fs = 0;
72         }
73       else
74         {
75           fs->p = fs->buf;
76           fs->end = fs->buf + INIT_BUF_SIZE;
77         }
78     }
79
80   return fs;
81 }
82 #ifdef weak_alias
83 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
84 #endif
85
86 /* Flush FS to its stream, and free it (but don't close the stream).  */
87 void
88 __argp_fmtstream_free (argp_fmtstream_t fs)
89 {
90   __argp_fmtstream_update (fs);
91   if (fs->p > fs->buf)
92     fwrite (fs->buf, 1, fs->p - fs->buf, fs->stream);
93   free (fs->buf);
94   free (fs);
95 }
96 #ifdef weak_alias
97 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
98 #endif
99 \f
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.  */
102 void
103 __argp_fmtstream_update (argp_fmtstream_t fs)
104 {
105   char *buf, *nl;
106   size_t len;
107
108   /* Scan the buffer for newlines.  */
109   buf = fs->buf + fs->point_offs;
110   while (buf < fs->p)
111     {
112       size_t r;
113
114       if (fs->point_col == 0 && fs->lmargin != 0)
115         {
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)
119             {
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.  */
126             }
127           else
128             {
129               /* No buffer space for spaces.  Must flush.  */
130               size_t i;
131               for (i = 0; i < pad; i++)
132                 putc (' ', fs->stream);
133             }
134           fs->point_col = pad;
135         }
136
137       len = fs->p - buf;
138       nl = memchr (buf, '\n', len);
139
140       if (fs->point_col < 0)
141         fs->point_col = 0;
142
143       if (!nl)
144         {
145           /* The buffer ends in a partial line.  */
146
147           if (fs->point_col + len < fs->rmargin)
148             {
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;
153               break;
154             }
155           else
156             /* Set the end-of-line pointer for the code below to
157                the end of the buffer.  */
158             nl = fs->p;
159         }
160       else if (fs->point_col + (nl - buf) < fs->rmargin)
161         {
162           /* The buffer contains a full line that fits within the maximum
163              line width.  Reset point and scan the next line.  */
164           fs->point_col = 0;
165           buf = nl + 1;
166           continue;
167         }
168
169       /* This line is too long.  */
170       r = fs->rmargin - 1;
171
172       if (fs->wmargin < 0)
173         {
174           /* Truncate the line by overwriting the excess with the
175              newline and anything after it in the buffer.  */
176           if (nl < fs->p)
177             {
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.  */
181               fs->point_col = 0;
182               buf += r + 1; /* Skip full line plus \n. */
183             }
184           else
185             {
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;
191               break;
192             }
193         }
194       else
195         {
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.  */
199
200           char *p, *nextline;
201           int i;
202
203           p = buf + (r + 1 - fs->point_col);
204           while (p >= buf && !isblank (*p))
205             --p;
206           nextline = p + 1;     /* This will begin the next line.  */
207
208           if (nextline > buf)
209             {
210               /* Swallow separating blanks.  */
211               if (p > buf)
212                 do
213                   --p;
214                 while (p > buf && isblank (*p));
215               nl = p + 1;       /* The newline will replace the first blank. */
216             }
217           else
218             {
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.  */
223               do
224                 ++p;
225               while (p < nl && !isblank (*p));
226               if (p == nl)
227                 {
228                   /* It already ends a line.  No fussing required.  */
229                   fs->point_col = 0;
230                   buf = nl + 1;
231                   continue;
232                 }
233               /* We will move the newline to replace the first blank.  */
234               nl = p;
235               /* Swallow separating blanks.  */
236               do
237                 ++p;
238               while (isblank (*p));
239               /* The next line will start here.  */
240               nextline = p;
241             }
242
243           if (nextline - (nl + 1) < fs->wmargin)
244             /* The margin needs more blanks than we removed.  */
245             if (fs->end - fs->p > fs->wmargin + 1)
246               /* Make some space for them.  */
247               {
248                 size_t mv = fs->p - nextline;
249                 memmove (nl + 1 + fs->wmargin, nextline, mv);
250                 nextline = nl + 1 + fs->wmargin;
251                 len = nextline + mv - buf;
252                 *nl++ = '\n';
253               }
254             else
255               /* Output the first line so we can use the space.  */
256               {
257                 if (nl > fs->buf)
258                   fwrite (fs->buf, 1, nl - fs->buf, fs->stream);
259                 putc ('\n', fs->stream);
260                 len += buf - fs->buf;
261                 nl = buf = fs->buf;
262               }
263           else
264             /* We can fit the newline and blanks in before
265                the next word.  */
266             *nl++ = '\n';
267
268           if (nextline - nl >= fs->wmargin)
269             /* Add blanks up to the wrap margin column.  */
270             for (i = 0; i < fs->wmargin; ++i)
271               *nl++ = ' ';
272           else
273             for (i = 0; i < fs->wmargin; ++i)
274               putc (' ', fs->stream);
275
276           /* Copy the tail of the original buffer into the current buffer
277              position.  */
278           if (nl != nextline)
279             memmove (nl, nextline, buf + len - nextline);
280           len -= nextline - buf;
281
282           /* Continue the scan on the remaining lines in the buffer.  */
283           buf = nl;
284
285           /* Restore bufp to include all the remaining text.  */
286           fs->p = nl + len;
287
288           /* Reset the counter of what has been output this line.  If wmargin
289              is 0, we want to avoid the lmargin getting added, so we set
290              point_col to a magic value of -1 in that case.  */
291           fs->point_col = fs->wmargin ? fs->wmargin : -1;
292         }
293     }
294
295   /* Remember that we've scanned as far as the end of the buffer.  */
296   fs->point_offs = fs->p - fs->buf;
297 }
298 \f
299 /* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
300    growing the buffer, or by flushing it.  True is returned iff we succeed. */
301 int
302 __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
303 {
304   if (fs->end - fs->p < amount)
305     {
306       ssize_t wrote;
307
308       /* Flush FS's buffer.  */
309       __argp_fmtstream_update (fs);
310
311       wrote = fwrite (fs->buf, 1, fs->p - fs->buf, fs->stream);
312       if (wrote == fs->p - fs->buf)
313         {
314           fs->p = fs->buf;
315           fs->point_offs = 0;
316         }
317       else
318         {
319           fs->p -= wrote;
320           fs->point_offs -= wrote;
321           memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
322           return 0;
323         }
324
325       if (fs->end - fs->buf < amount)
326         /* Gotta grow the buffer.  */
327         {
328           size_t new_size = fs->end - fs->buf + amount;
329           char *new_buf = realloc (fs->buf, new_size);
330
331           if (! new_buf)
332             {
333               __set_errno (ENOMEM);
334               return 0;
335             }
336
337           fs->buf = new_buf;
338           fs->end = new_buf + new_size;
339           fs->p = fs->buf;
340         }
341     }
342
343   return 1;
344 }
345 \f
346 ssize_t
347 __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
348 {
349   size_t out;
350   size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
351
352   do
353     {
354       va_list args;
355
356       if (! __argp_fmtstream_ensure (fs, size_guess))
357         return -1;
358       size_guess += size_guess;
359
360       va_start (args, fmt);
361       out = __vsnprintf (fs->p, fs->end - fs->p, fmt, args);
362       va_end (args);
363     }
364   while (out == -1);
365
366   fs->p += out;
367
368   return out;
369 }
370 #ifdef weak_alias
371 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
372 #endif
373
374 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */