argp/argp-fmtstream.c

   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>.
   5
   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.
  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    Lesser General Public License for more details.
  15
  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.  */
  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 #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
  48
  49 #define INIT_BUF_SIZE 200
  50 #define PRINTF_SIZE_GUESS 150
  51 \f
  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)
  61 {
  62   argp_fmtstream_t fs;
  63
  64   fs = (struct argp_fmtstream *) malloc (sizeof (struct argp_fmtstream));
  65   if (fs != NULL)
  66     {
  67       fs->stream = stream;
  68
  69       fs->lmargin = lmargin;
  70       fs->rmargin = rmargin;
  71       fs->wmargin = wmargin;
  72       fs->point_col = 0;
  73       fs->point_offs = 0;
  74
  75       fs->buf = (char *) malloc (INIT_BUF_SIZE);
  76       if (! fs->buf)
  77         {
  78           free (fs);
  79           fs = 0;
  80         }
  81       else
  82         {
  83           fs->p = fs->buf;
  84           fs->end = fs->buf + INIT_BUF_SIZE;
  85         }
  86     }
  87
  88   return fs;
  89 }
  90 #if 0
  91 /* Not exported.  */
  92 #ifdef weak_alias
  93 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
  94 #endif
  95 #endif
  96
  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)
 100 {
 101   __argp_fmtstream_update (fs);
 102   if (fs->p > fs->buf)
 103     {
 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);
 110     }
 111   free (fs->buf);
 112   free (fs);
 113 }
 114 #if 0
 115 /* Not exported.  */
 116 #ifdef weak_alias
 117 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
 118 #endif
 119 #endif
 120 \f
 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)
 125 {
 126   char *buf, *nl;
 127   size_t len;
 128
 129   /* Scan the buffer for newlines.  */
 130   buf = fs->buf + fs->point_offs;
 131   while (buf < fs->p)
 132     {
 133       size_t r;
 134
 135       if (fs->point_col == 0 && fs->lmargin != 0)
 136         {
 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)
 140             {
 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.  */
 147             }
 148           else
 149             {
 150               /* No buffer space for spaces.  Must flush.  */
 151               size_t i;
 152               for (i = 0; i < pad; i++)
 153                 {
 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);
 160                 }
 161             }
 162           fs->point_col = pad;
 163         }
 164
 165       len = fs->p - buf;
 166       nl = memchr (buf, '\n', len);
 167
 168       if (fs->point_col < 0)
 169         fs->point_col = 0;
 170
 171       if (!nl)
 172         {
 173           /* The buffer ends in a partial line.  */
 174
 175           if (fs->point_col + len < fs->rmargin)
 176             {
 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;
 182             }
 183           else
 184             /* Set the end-of-line pointer for the code below to
 185                the end of the buffer.  */
 186             nl = fs->p;
 187         }
 188       else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
 189         {
 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;
 195         }
 196
 197       /* This line is too long.  */
 198       r = fs->rmargin - 1;
 199
 200       if (fs->wmargin < 0)
 201         {
 202           /* Truncate the line by overwriting the excess with the
 203              newline and anything after it in the buffer.  */
 204           if (nl < fs->p)
 205             {
 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. */
 211             }
 212           else
 213             {
 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;
 220             }
 221         }
 222       else
 223         {
 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.  */
 227
 228           char *p, *nextline;
 229           int i;
 230
 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.  */
 235
 236           if (nextline > buf)
 237             {
 238               /* Swallow separating blanks.  */
 239               if (p >= buf)
 240                 do
 241                   --p;
 242                 while (p >= buf && isblank (*p));
 243               nl = p + 1;       /* The newline will replace the first blank. */
 244             }
 245           else
 246             {
 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.  */
 251               do
 252                 ++p;
 253               while (p < nl && !isblank (*p));
 254               if (p == nl)
 255                 {
 256                   /* It already ends a line.  No fussing required.  */
 257                   fs->point_col = 0;
 258                   buf = nl + 1;
 259                   continue;
 260                 }
 261               /* We will move the newline to replace the first blank.  */
 262               nl = p;
 263               /* Swallow separating blanks.  */
 264               do
 265                 ++p;
 266               while (isblank (*p));
 267               /* The next line will start here.  */
 268               nextline = p;
 269             }
 270
 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).  */
 275
 276           if ((nextline == buf + len + 1
 277                ? fs->end - nl < fs->wmargin + 1
 278                : nextline - (nl + 1) < fs->wmargin)
 279               && fs->p > nextline)
 280             {
 281               /* The margin needs more blanks than we removed.  */
 282               if (fs->end - fs->p > fs->wmargin + 1)
 283                 /* Make some space for them.  */
 284                 {
 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';
 290                 }
 291               else
 292                 /* Output the first line so we can use the space.  */
 293                 {
 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
 300                     {
 301                       if (nl > fs->buf)
 302                         fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
 303                       putc_unlocked ('\n', fs->stream);
 304                     }
 305                   len += buf - fs->buf;
 306                   nl = buf = fs->buf;
 307                 }
 308             }
 309           else
 310             /* We can fit the newline and blanks in before
 311                the next word.  */
 312             *nl++ = '\n';
 313
 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);
 327
 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;
 333
 334           /* Continue the scan on the remaining lines in the buffer.  */
 335           buf = nl;
 336
 337           /* Restore bufp to include all the remaining text.  */
 338           fs->p = nl + len;
 339
 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;
 344         }
 345     }
 346
 347   /* Remember that we've scanned as far as the end of the buffer.  */
 348   fs->point_offs = fs->p - fs->buf;
 349 }
 350 \f
 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. */
 353 int
 354 __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
 355 {
 356   if ((size_t) (fs->end - fs->p) < amount)
 357     {
 358       ssize_t wrote;
 359
 360       /* Flush FS's buffer.  */
 361       __argp_fmtstream_update (fs);
 362
 363 #ifdef USE_IN_LIBIO
 364       if (_IO_fwide (fs->stream, 0) > 0)
 365         {
 366           __fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
 367           wrote = fs->p - fs->buf;
 368         }
 369       else
 370 #endif
 371         wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 372       if (wrote == fs->p - fs->buf)
 373         {
 374           fs->p = fs->buf;
 375           fs->point_offs = 0;
 376         }
 377       else
 378         {
 379           fs->p -= wrote;
 380           fs->point_offs -= wrote;
 381           memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
 382           return 0;
 383         }
 384
 385       if ((size_t) (fs->end - fs->buf) < amount)
 386         /* Gotta grow the buffer.  */
 387         {
 388           size_t old_size = fs->end - fs->buf;
 389           size_t new_size = old_size + amount;
 390           char *new_buf;
 391
 392           if (new_size < old_size || ! (new_buf = realloc (fs->buf, new_size)))
 393             {
 394               __set_errno (ENOMEM);
 395               return 0;
 396             }
 397
 398           fs->buf = new_buf;
 399           fs->end = new_buf + new_size;
 400           fs->p = fs->buf;
 401         }
 402     }
 403
 404   return 1;
 405 }
 406 \f
 407 ssize_t
 408 __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
 409 {
 410   int out;
 411   size_t avail;
 412   size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
 413
 414   do
 415     {
 416       va_list args;
 417
 418       if (! __argp_fmtstream_ensure (fs, size_guess))
 419         return -1;
 420
 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;
 427     }
 428   while ((size_t) out >= avail);
 429
 430   fs->p += out;
 431
 432   return out;
 433 }
 434 #if 0
 435 /* Not exported.  */
 436 #ifdef weak_alias
 437 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
 438 #endif
 439 #endif
 440
 441 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */