argp/argp-fmtstream.c

   1 /* Word-wrapping and line-truncating streams
   2    Copyright (C) 1997, 1998, 1999, 2001, 2002 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 #ifdef weak_alias
  91 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
  92 #endif
  93
  94 /* Flush FS to its stream, and free it (but don't close the stream).  */
  95 void
  96 __argp_fmtstream_free (argp_fmtstream_t fs)
  97 {
  98   __argp_fmtstream_update (fs);
  99   if (fs->p > fs->buf)
 100     {
 101 #ifdef USE_IN_LIBIO
 102       if (_IO_fwide (fs->stream, 0) > 0)
 103         __fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
 104       else
 105 #endif
 106         fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 107     }
 108   free (fs->buf);
 109   free (fs);
 110 }
 111 #ifdef weak_alias
 112 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
 113 #endif
 114 \f
 115 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
 116    end of its buffer.  This code is mostly from glibc stdio/linewrap.c.  */
 117 void
 118 __argp_fmtstream_update (argp_fmtstream_t fs)
 119 {
 120   char *buf, *nl;
 121   size_t len;
 122
 123   /* Scan the buffer for newlines.  */
 124   buf = fs->buf + fs->point_offs;
 125   while (buf < fs->p)
 126     {
 127       size_t r;
 128
 129       if (fs->point_col == 0 && fs->lmargin != 0)
 130         {
 131           /* We are starting a new line.  Print spaces to the left margin.  */
 132           const size_t pad = fs->lmargin;
 133           if (fs->p + pad < fs->end)
 134             {
 135               /* We can fit in them in the buffer by moving the
 136                  buffer text up and filling in the beginning.  */
 137               memmove (buf + pad, buf, fs->p - buf);
 138               fs->p += pad; /* Compensate for bigger buffer. */
 139               memset (buf, ' ', pad); /* Fill in the spaces.  */
 140               buf += pad; /* Don't bother searching them.  */
 141             }
 142           else
 143             {
 144               /* No buffer space for spaces.  Must flush.  */
 145               size_t i;
 146               for (i = 0; i < pad; i++)
 147                 {
 148 #ifdef USE_IN_LIBIO
 149                   if (_IO_fwide (fs->stream, 0) > 0)
 150                     putwc_unlocked (L' ', fs->stream);
 151                   else
 152 #endif
 153                     putc_unlocked (' ', fs->stream);
 154                 }
 155             }
 156           fs->point_col = pad;
 157         }
 158
 159       len = fs->p - buf;
 160       nl = memchr (buf, '\n', len);
 161
 162       if (fs->point_col < 0)
 163         fs->point_col = 0;
 164
 165       if (!nl)
 166         {
 167           /* The buffer ends in a partial line.  */
 168
 169           if (fs->point_col + len < fs->rmargin)
 170             {
 171               /* The remaining buffer text is a partial line and fits
 172                  within the maximum line width.  Advance point for the
 173                  characters to be written and stop scanning.  */
 174               fs->point_col += len;
 175               break;
 176             }
 177           else
 178             /* Set the end-of-line pointer for the code below to
 179                the end of the buffer.  */
 180             nl = fs->p;
 181         }
 182       else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
 183         {
 184           /* The buffer contains a full line that fits within the maximum
 185              line width.  Reset point and scan the next line.  */
 186           fs->point_col = 0;
 187           buf = nl + 1;
 188           continue;
 189         }
 190
 191       /* This line is too long.  */
 192       r = fs->rmargin - 1;
 193
 194       if (fs->wmargin < 0)
 195         {
 196           /* Truncate the line by overwriting the excess with the
 197              newline and anything after it in the buffer.  */
 198           if (nl < fs->p)
 199             {
 200               memmove (buf + (r - fs->point_col), nl, fs->p - nl);
 201               fs->p -= buf + (r - fs->point_col) - nl;
 202               /* Reset point for the next line and start scanning it.  */
 203               fs->point_col = 0;
 204               buf += r + 1; /* Skip full line plus \n. */
 205             }
 206           else
 207             {
 208               /* The buffer ends with a partial line that is beyond the
 209                  maximum line width.  Advance point for the characters
 210                  written, and discard those past the max from the buffer.  */
 211               fs->point_col += len;
 212               fs->p -= fs->point_col - r;
 213               break;
 214             }
 215         }
 216       else
 217         {
 218           /* Do word wrap.  Go to the column just past the maximum line
 219              width and scan back for the beginning of the word there.
 220              Then insert a line break.  */
 221
 222           char *p, *nextline;
 223           int i;
 224
 225           p = buf + (r + 1 - fs->point_col);
 226           while (p >= buf && !isblank (*p))
 227             --p;
 228           nextline = p + 1;     /* This will begin the next line.  */
 229
 230           if (nextline > buf)
 231             {
 232               /* Swallow separating blanks.  */
 233               if (p >= buf)
 234                 do
 235                   --p;
 236                 while (p >= buf && isblank (*p));
 237               nl = p + 1;       /* The newline will replace the first blank. */
 238             }
 239           else
 240             {
 241               /* A single word that is greater than the maximum line width.
 242                  Oh well.  Put it on an overlong line by itself.  */
 243               p = buf + (r + 1 - fs->point_col);
 244               /* Find the end of the long word.  */
 245               do
 246                 ++p;
 247               while (p < nl && !isblank (*p));
 248               if (p == nl)
 249                 {
 250                   /* It already ends a line.  No fussing required.  */
 251                   fs->point_col = 0;
 252                   buf = nl + 1;
 253                   continue;
 254                 }
 255               /* We will move the newline to replace the first blank.  */
 256               nl = p;
 257               /* Swallow separating blanks.  */
 258               do
 259                 ++p;
 260               while (isblank (*p));
 261               /* The next line will start here.  */
 262               nextline = p;
 263             }
 264
 265           /* Note: There are a bunch of tests below for
 266              NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
 267              at the end of the buffer, and NEXTLINE is in fact empty (and so
 268              we need not be careful to maintain its contents).  */
 269
 270           if ((nextline == buf + len + 1
 271                ? fs->end - nl < fs->wmargin + 1
 272                : nextline - (nl + 1) < fs->wmargin)
 273               && fs->p > nextline)
 274             {
 275               /* The margin needs more blanks than we removed.  */
 276               if (fs->end - fs->p > fs->wmargin + 1)
 277                 /* Make some space for them.  */
 278                 {
 279                   size_t mv = fs->p - nextline;
 280                   memmove (nl + 1 + fs->wmargin, nextline, mv);
 281                   nextline = nl + 1 + fs->wmargin;
 282                   len = nextline + mv - buf;
 283                   *nl++ = '\n';
 284                 }
 285               else
 286                 /* Output the first line so we can use the space.  */
 287                 {
 288 #ifdef USE_IN_LIBIO
 289                   if (_IO_fwide (fs->stream, 0) > 0)
 290                     __fwprintf (fs->stream, L"%.*s\n",
 291                                 (int) (nl - fs->buf), fs->buf);
 292                   else
 293 #endif
 294                     {
 295                       if (nl > fs->buf)
 296                         fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
 297                       putc_unlocked ('\n', fs->stream);
 298                     }
 299                   len += buf - fs->buf;
 300                   nl = buf = fs->buf;
 301                 }
 302             }
 303           else
 304             /* We can fit the newline and blanks in before
 305                the next word.  */
 306             *nl++ = '\n';
 307
 308           if (nextline - nl >= fs->wmargin
 309               || (nextline == buf + len + 1 && fs->end - nextline >= fs->wmargin))
 310             /* Add blanks up to the wrap margin column.  */
 311             for (i = 0; i < fs->wmargin; ++i)
 312               *nl++ = ' ';
 313           else
 314             for (i = 0; i < fs->wmargin; ++i)
 315 #ifdef USE_IN_LIBIO
 316               if (_IO_fwide (fs->stream, 0) > 0)
 317                 putwc_unlocked (L' ', fs->stream);
 318               else
 319 #endif
 320                 putc_unlocked (' ', fs->stream);
 321
 322           /* Copy the tail of the original buffer into the current buffer
 323              position.  */
 324           if (nl < nextline)
 325             memmove (nl, nextline, buf + len - nextline);
 326           len -= nextline - buf;
 327
 328           /* Continue the scan on the remaining lines in the buffer.  */
 329           buf = nl;
 330
 331           /* Restore bufp to include all the remaining text.  */
 332           fs->p = nl + len;
 333
 334           /* Reset the counter of what has been output this line.  If wmargin
 335              is 0, we want to avoid the lmargin getting added, so we set
 336              point_col to a magic value of -1 in that case.  */
 337           fs->point_col = fs->wmargin ? fs->wmargin : -1;
 338         }
 339     }
 340
 341   /* Remember that we've scanned as far as the end of the buffer.  */
 342   fs->point_offs = fs->p - fs->buf;
 343 }
 344 \f
 345 /* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
 346    growing the buffer, or by flushing it.  True is returned iff we succeed. */
 347 int
 348 __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
 349 {
 350   if ((size_t) (fs->end - fs->p) < amount)
 351     {
 352       ssize_t wrote;
 353
 354       /* Flush FS's buffer.  */
 355       __argp_fmtstream_update (fs);
 356
 357 #ifdef USE_IN_LIBIO
 358       if (_IO_fwide (fs->stream, 0) > 0)
 359         {
 360           __fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
 361           wrote = fs->p - fs->buf;
 362         }
 363       else
 364 #endif
 365         wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 366       if (wrote == fs->p - fs->buf)
 367         {
 368           fs->p = fs->buf;
 369           fs->point_offs = 0;
 370         }
 371       else
 372         {
 373           fs->p -= wrote;
 374           fs->point_offs -= wrote;
 375           memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
 376           return 0;
 377         }
 378
 379       if ((size_t) (fs->end - fs->buf) < amount)
 380         /* Gotta grow the buffer.  */
 381         {
 382           size_t new_size = fs->end - fs->buf + amount;
 383           char *new_buf = realloc (fs->buf, new_size);
 384
 385           if (! new_buf)
 386             {
 387               __set_errno (ENOMEM);
 388               return 0;
 389             }
 390
 391           fs->buf = new_buf;
 392           fs->end = new_buf + new_size;
 393           fs->p = fs->buf;
 394         }
 395     }
 396
 397   return 1;
 398 }
 399 \f
 400 ssize_t
 401 __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
 402 {
 403   int out;
 404   size_t avail;
 405   size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
 406
 407   do
 408     {
 409       va_list args;
 410
 411       if (! __argp_fmtstream_ensure (fs, size_guess))
 412         return -1;
 413
 414       va_start (args, fmt);
 415       avail = fs->end - fs->p;
 416       out = __vsnprintf (fs->p, avail, fmt, args);
 417       va_end (args);
 418       if ((size_t) out >= avail)
 419         size_guess = out + 1;
 420     }
 421   while ((size_t) out >= avail);
 422
 423   fs->p += out;
 424
 425   return out;
 426 }
 427 #ifdef weak_alias
 428 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
 429 #endif
 430
 431 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */