lib/argp-fmtstream.c

   1 /* Word-wrapping and line-truncating streams
   2    Copyright (C) 1997-1999,2001,2002,2003,2005 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    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program 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
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
  19
  20 /* This package emulates glibc `line_wrap_stream' semantics for systems that
  21    don't have that.  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <stdarg.h>
  31 #include <ctype.h>
  32
  33 #include "argp-fmtstream.h"
  34 #include "argp-namefrob.h"
  35
  36 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
  37
  38 #ifndef isblank
  39 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
  40 #endif
  41
  42 #if defined _LIBC && defined USE_IN_LIBIO
  43 # include <wchar.h>
  44 # include <libio/libioP.h>
  45 # define __vsnprintf(s, l, f, a) _IO_vsnprintf (s, l, f, a)
  46 #endif
  47
  48 #define INIT_BUF_SIZE 200
  49 #define PRINTF_SIZE_GUESS 150
  50 \f
  51 /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
  52    written on it with LMARGIN spaces and limits them to RMARGIN columns
  53    total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
  54    replacing the whitespace before them with a newline and WMARGIN spaces.
  55    Otherwise, chars beyond RMARGIN are simply dropped until a newline.
  56    Returns NULL if there was an error.  */
  57 argp_fmtstream_t
  58 __argp_make_fmtstream (FILE *stream,
  59                        size_t lmargin, size_t rmargin, ssize_t wmargin)
  60 {
  61   argp_fmtstream_t fs;
  62
  63   fs = (struct argp_fmtstream *) malloc (sizeof (struct argp_fmtstream));
  64   if (fs != NULL)
  65     {
  66       fs->stream = stream;
  67
  68       fs->lmargin = lmargin;
  69       fs->rmargin = rmargin;
  70       fs->wmargin = wmargin;
  71       fs->point_col = 0;
  72       fs->point_offs = 0;
  73
  74       fs->buf = (char *) malloc (INIT_BUF_SIZE);
  75       if (! fs->buf)
  76         {
  77           free (fs);
  78           fs = 0;
  79         }
  80       else
  81         {
  82           fs->p = fs->buf;
  83           fs->end = fs->buf + INIT_BUF_SIZE;
  84         }
  85     }
  86
  87   return fs;
  88 }
  89 #if 0
  90 /* Not exported.  */
  91 #ifdef weak_alias
  92 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
  93 #endif
  94 #endif
  95
  96 /* Flush FS to its stream, and free it (but don't close the stream).  */
  97 void
  98 __argp_fmtstream_free (argp_fmtstream_t fs)
  99 {
 100   __argp_fmtstream_update (fs);
 101   if (fs->p > fs->buf)
 102     {
 103 #ifdef USE_IN_LIBIO
 104       __fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
 105 #else
 106       fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 107 #endif
 108     }
 109   free (fs->buf);
 110   free (fs);
 111 }
 112 #if 0
 113 /* Not exported.  */
 114 #ifdef weak_alias
 115 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
 116 #endif
 117 #endif
 118 \f
 119 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
 120    end of its buffer.  This code is mostly from glibc stdio/linewrap.c.  */
 121 void
 122 __argp_fmtstream_update (argp_fmtstream_t fs)
 123 {
 124   char *buf, *nl;
 125   size_t len;
 126
 127   /* Scan the buffer for newlines.  */
 128   buf = fs->buf + fs->point_offs;
 129   while (buf < fs->p)
 130     {
 131       size_t r;
 132
 133       if (fs->point_col == 0 && fs->lmargin != 0)
 134         {
 135           /* We are starting a new line.  Print spaces to the left margin.  */
 136           const size_t pad = fs->lmargin;
 137           if (fs->p + pad < fs->end)
 138             {
 139               /* We can fit in them in the buffer by moving the
 140                  buffer text up and filling in the beginning.  */
 141               memmove (buf + pad, buf, fs->p - buf);
 142               fs->p += pad; /* Compensate for bigger buffer. */
 143               memset (buf, ' ', pad); /* Fill in the spaces.  */
 144               buf += pad; /* Don't bother searching them.  */
 145             }
 146           else
 147             {
 148               /* No buffer space for spaces.  Must flush.  */
 149               size_t i;
 150               for (i = 0; i < pad; i++)
 151                 {
 152 #ifdef USE_IN_LIBIO
 153                   if (_IO_fwide (fs->stream, 0) > 0)
 154                     putwc_unlocked (L' ', fs->stream);
 155                   else
 156 #endif
 157                     putc_unlocked (' ', fs->stream);
 158                 }
 159             }
 160           fs->point_col = pad;
 161         }
 162
 163       len = fs->p - buf;
 164       nl = memchr (buf, '\n', len);
 165
 166       if (fs->point_col < 0)
 167         fs->point_col = 0;
 168
 169       if (!nl)
 170         {
 171           /* The buffer ends in a partial line.  */
 172
 173           if (fs->point_col + len < fs->rmargin)
 174             {
 175               /* The remaining buffer text is a partial line and fits
 176                  within the maximum line width.  Advance point for the
 177                  characters to be written and stop scanning.  */
 178               fs->point_col += len;
 179               break;
 180             }
 181           else
 182             /* Set the end-of-line pointer for the code below to
 183                the end of the buffer.  */
 184             nl = fs->p;
 185         }
 186       else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
 187         {
 188           /* The buffer contains a full line that fits within the maximum
 189              line width.  Reset point and scan the next line.  */
 190           fs->point_col = 0;
 191           buf = nl + 1;
 192           continue;
 193         }
 194
 195       /* This line is too long.  */
 196       r = fs->rmargin - 1;
 197
 198       if (fs->wmargin < 0)
 199         {
 200           /* Truncate the line by overwriting the excess with the
 201              newline and anything after it in the buffer.  */
 202           if (nl < fs->p)
 203             {
 204               memmove (buf + (r - fs->point_col), nl, fs->p - nl);
 205               fs->p -= buf + (r - fs->point_col) - nl;
 206               /* Reset point for the next line and start scanning it.  */
 207               fs->point_col = 0;
 208               buf += r + 1; /* Skip full line plus \n. */
 209             }
 210           else
 211             {
 212               /* The buffer ends with a partial line that is beyond the
 213                  maximum line width.  Advance point for the characters
 214                  written, and discard those past the max from the buffer.  */
 215               fs->point_col += len;
 216               fs->p -= fs->point_col - r;
 217               break;
 218             }
 219         }
 220       else
 221         {
 222           /* Do word wrap.  Go to the column just past the maximum line
 223              width and scan back for the beginning of the word there.
 224              Then insert a line break.  */
 225
 226           char *p, *nextline;
 227           int i;
 228
 229           p = buf + (r + 1 - fs->point_col);
 230           while (p >= buf && !isblank (*p))
 231             --p;
 232           nextline = p + 1;     /* This will begin the next line.  */
 233
 234           if (nextline > buf)
 235             {
 236               /* Swallow separating blanks.  */
 237               if (p >= buf)
 238                 do
 239                   --p;
 240                 while (p >= buf && isblank (*p));
 241               nl = p + 1;       /* The newline will replace the first blank. */
 242             }
 243           else
 244             {
 245               /* A single word that is greater than the maximum line width.
 246                  Oh well.  Put it on an overlong line by itself.  */
 247               p = buf + (r + 1 - fs->point_col);
 248               /* Find the end of the long word.  */
 249               do
 250                 ++p;
 251               while (p < nl && !isblank (*p));
 252               if (p == nl)
 253                 {
 254                   /* It already ends a line.  No fussing required.  */
 255                   fs->point_col = 0;
 256                   buf = nl + 1;
 257                   continue;
 258                 }
 259               /* We will move the newline to replace the first blank.  */
 260               nl = p;
 261               /* Swallow separating blanks.  */
 262               do
 263                 ++p;
 264               while (isblank (*p));
 265               /* The next line will start here.  */
 266               nextline = p;
 267             }
 268
 269           /* Note: There are a bunch of tests below for
 270              NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
 271              at the end of the buffer, and NEXTLINE is in fact empty (and so
 272              we need not be careful to maintain its contents).  */
 273
 274           if ((nextline == buf + len + 1
 275                ? fs->end - nl < fs->wmargin + 1
 276                : nextline - (nl + 1) < fs->wmargin)
 277               && fs->p > nextline)
 278             {
 279               /* The margin needs more blanks than we removed.  */
 280               if (fs->end - fs->p > fs->wmargin + 1)
 281                 /* Make some space for them.  */
 282                 {
 283                   size_t mv = fs->p - nextline;
 284                   memmove (nl + 1 + fs->wmargin, nextline, mv);
 285                   nextline = nl + 1 + fs->wmargin;
 286                   len = nextline + mv - buf;
 287                   *nl++ = '\n';
 288                 }
 289               else
 290                 /* Output the first line so we can use the space.  */
 291                 {
 292 #ifdef _LIBC
 293                   __fxprintf (fs->stream, "%.*s\n",
 294                               (int) (nl - fs->buf), fs->buf);
 295 #else
 296                   if (nl > fs->buf)
 297                     fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
 298                   putc_unlocked ('\n', fs->stream);
 299 #endif
 300
 301                   len += buf - fs->buf;
 302                   nl = buf = fs->buf;
 303                 }
 304             }
 305           else
 306             /* We can fit the newline and blanks in before
 307                the next word.  */
 308             *nl++ = '\n';
 309
 310           if (nextline - nl >= fs->wmargin
 311               || (nextline == buf + len + 1 && fs->end - nextline >= fs->wmargin))
 312             /* Add blanks up to the wrap margin column.  */
 313             for (i = 0; i < fs->wmargin; ++i)
 314               *nl++ = ' ';
 315           else
 316             for (i = 0; i < fs->wmargin; ++i)
 317 #ifdef USE_IN_LIBIO
 318               if (_IO_fwide (fs->stream, 0) > 0)
 319                 putwc_unlocked (L' ', fs->stream);
 320               else
 321 #endif
 322                 putc_unlocked (' ', fs->stream);
 323
 324           /* Copy the tail of the original buffer into the current buffer
 325              position.  */
 326           if (nl < nextline)
 327             memmove (nl, nextline, buf + len - nextline);
 328           len -= nextline - buf;
 329
 330           /* Continue the scan on the remaining lines in the buffer.  */
 331           buf = nl;
 332
 333           /* Restore bufp to include all the remaining text.  */
 334           fs->p = nl + len;
 335
 336           /* Reset the counter of what has been output this line.  If wmargin
 337              is 0, we want to avoid the lmargin getting added, so we set
 338              point_col to a magic value of -1 in that case.  */
 339           fs->point_col = fs->wmargin ? fs->wmargin : -1;
 340         }
 341     }
 342
 343   /* Remember that we've scanned as far as the end of the buffer.  */
 344   fs->point_offs = fs->p - fs->buf;
 345 }
 346 \f
 347 /* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
 348    growing the buffer, or by flushing it.  True is returned iff we succeed. */
 349 int
 350 __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
 351 {
 352   if ((size_t) (fs->end - fs->p) < amount)
 353     {
 354       ssize_t wrote;
 355
 356       /* Flush FS's buffer.  */
 357       __argp_fmtstream_update (fs);
 358
 359 #ifdef _LIBC
 360       __fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
 361       wrote = fs->p - fs->buf;
 362 #else
 363       wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 364 #endif
 365       if (wrote == fs->p - fs->buf)
 366         {
 367           fs->p = fs->buf;
 368           fs->point_offs = 0;
 369         }
 370       else
 371         {
 372           fs->p -= wrote;
 373           fs->point_offs -= wrote;
 374           memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
 375           return 0;
 376         }
 377
 378       if ((size_t) (fs->end - fs->buf) < amount)
 379         /* Gotta grow the buffer.  */
 380         {
 381           size_t old_size = fs->end - fs->buf;
 382           size_t new_size = old_size + amount;
 383           char *new_buf;
 384
 385           if (new_size < old_size || ! (new_buf = realloc (fs->buf, new_size)))
 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 #if 0
 428 /* Not exported.  */
 429 #ifdef weak_alias
 430 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
 431 #endif
 432 #endif
 433
 434 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */