argp/argp-fmtstream.c

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