argp/argp-fmtstream.c

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