libuargp/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 at 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; see the file COPYING.LIB.  If
  18    not, see <http://www.gnu.org/licenses/>.
  19
  20    Modified for uClibc by: Salvatore Cro <salvatore.cro at st.com>
  21 */
  22
  23 /* This package emulates glibc `line_wrap_stream' semantics for systems that
  24    don't have that.  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include <config.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33 #include <stdarg.h>
  34 #include <ctype.h>
  35
  36 #include "argp-fmtstream.h"
  37
  38 #ifndef ARGP_FMTSTREAM_USE_LINEWRAP
  39
  40 #ifndef isblank
  41 #define isblank(ch) ((ch)==' ' || (ch)=='\t')
  42 #endif
  43
  44 #if defined _LIBC && defined USE_IN_LIBIO
  45 # include <wchar.h>
  46 # include <libio/libioP.h>
  47 # define __vsnprintf(s, l, f, a) _IO_vsnprintf (s, l, f, a)
  48 #else
  49 # define __vsnprintf(s, l, f, a) vsnprintf (s, l, f, a)
  50 #endif
  51
  52 #define INIT_BUF_SIZE 200
  53 #define PRINTF_SIZE_GUESS 150
  54
  55 /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
  56    written on it with LMARGIN spaces and limits them to RMARGIN columns
  57    total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
  58    replacing the whitespace before them with a newline and WMARGIN spaces.
  59    Otherwise, chars beyond RMARGIN are simply dropped until a newline.
  60    Returns NULL if there was an error.  */
  61 argp_fmtstream_t
  62 __argp_make_fmtstream (FILE *stream,
  63                       size_t lmargin, size_t rmargin, ssize_t wmargin)
  64 {
  65   argp_fmtstream_t fs;
  66
  67   fs = (struct argp_fmtstream *) malloc (sizeof (struct argp_fmtstream));
  68   if (fs != NULL)
  69     {
  70       fs->stream = stream;
  71
  72       fs->lmargin = lmargin;
  73       fs->rmargin = rmargin;
  74       fs->wmargin = wmargin;
  75       fs->point_col = 0;
  76       fs->point_offs = 0;
  77
  78       fs->buf = (char *) malloc (INIT_BUF_SIZE);
  79       if (! fs->buf)
  80        {
  81          free (fs);
  82          fs = 0;
  83        }
  84       else
  85        {
  86          fs->p = fs->buf;
  87          fs->end = fs->buf + INIT_BUF_SIZE;
  88        }
  89     }
  90
  91   return fs;
  92 }
  93 #if 0
  94 /* Not exported.  */
  95 #ifdef weak_alias
  96 weak_alias (__argp_make_fmtstream, argp_make_fmtstream)
  97 #endif
  98 #endif
  99
 100 /* Flush FS to its stream, and free it (but don't close the stream).  */
 101 void
 102 __argp_fmtstream_free (argp_fmtstream_t fs)
 103 {
 104   __argp_fmtstream_update (fs);
 105   if (fs->p > fs->buf)
 106     {
 107 #ifdef USE_IN_LIBIO
 108       __fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
 109 #else
 110       fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 111 #endif
 112     }
 113   free (fs->buf);
 114   free (fs);
 115 }
 116 #if 0
 117 /* Not exported.  */
 118 #ifdef weak_alias
 119 weak_alias (__argp_fmtstream_free, argp_fmtstream_free)
 120 #endif
 121 #endif
 122
 123 /* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
 124    end of its buffer.  This code is mostly from glibc stdio/linewrap.c.  */
 125 void
 126 __argp_fmtstream_update (argp_fmtstream_t fs)
 127 {
 128   char *buf, *nl;
 129   size_t len;
 130
 131   /* Scan the buffer for newlines.  */
 132   buf = fs->buf + fs->point_offs;
 133   while (buf < fs->p)
 134     {
 135       size_t r;
 136
 137       if (fs->point_col == 0 && fs->lmargin != 0)
 138        {
 139          /* We are starting a new line.  Print spaces to the left margin.  */
 140          const size_t pad = fs->lmargin;
 141          if (fs->p + pad < fs->end)
 142            {
 143              /* We can fit in them in the buffer by moving the
 144                 buffer text up and filling in the beginning.  */
 145              memmove (buf + pad, buf, fs->p - buf);
 146              fs->p += pad; /* Compensate for bigger buffer. */
 147              memset (buf, ' ', pad); /* Fill in the spaces.  */
 148              buf += pad; /* Don't bother searching them.  */
 149            }
 150          else
 151            {
 152              /* No buffer space for spaces.  Must flush.  */
 153              size_t i;
 154              for (i = 0; i < pad; i++)
 155                {
 156 #ifdef USE_IN_LIBIO
 157                  if (_IO_fwide (fs->stream, 0) > 0)
 158                    putwc_unlocked (L' ', fs->stream);
 159                  else
 160 #endif
 161                    putc_unlocked (' ', fs->stream);
 162                }
 163            }
 164          fs->point_col = pad;
 165        }
 166
 167       len = fs->p - buf;
 168       nl = memchr (buf, '\n', len);
 169
 170       if (fs->point_col < 0)
 171        fs->point_col = 0;
 172
 173       if (!nl)
 174        {
 175          /* The buffer ends in a partial line.  */
 176
 177          if (fs->point_col + len < fs->rmargin)
 178            {
 179              /* The remaining buffer text is a partial line and fits
 180                 within the maximum line width.  Advance point for the
 181                 characters to be written and stop scanning.  */
 182              fs->point_col += len;
 183              break;
 184            }
 185          else
 186            /* Set the end-of-line pointer for the code below to
 187               the end of the buffer.  */
 188            nl = fs->p;
 189        }
 190       else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
 191        {
 192          /* The buffer contains a full line that fits within the maximum
 193             line width.  Reset point and scan the next line.  */
 194          fs->point_col = 0;
 195          buf = nl + 1;
 196          continue;
 197        }
 198
 199       /* This line is too long.  */
 200       r = fs->rmargin - 1;
 201
 202       if (fs->wmargin < 0)
 203        {
 204          /* Truncate the line by overwriting the excess with the
 205             newline and anything after it in the buffer.  */
 206          if (nl < fs->p)
 207            {
 208              memmove (buf + (r - fs->point_col), nl, fs->p - nl);
 209              fs->p -= buf + (r - fs->point_col) - nl;
 210              /* Reset point for the next line and start scanning it.  */
 211              fs->point_col = 0;
 212              buf += r + 1; /* Skip full line plus \n. */
 213            }
 214          else
 215            {
 216              /* The buffer ends with a partial line that is beyond the
 217                 maximum line width.  Advance point for the characters
 218                 written, and discard those past the max from the buffer.  */
 219              fs->point_col += len;
 220              fs->p -= fs->point_col - r;
 221              break;
 222            }
 223        }
 224       else
 225        {
 226          /* Do word wrap.  Go to the column just past the maximum line
 227             width and scan back for the beginning of the word there.
 228             Then insert a line break.  */
 229
 230          char *p, *nextline;
 231          int i;
 232
 233          p = buf + (r + 1 - fs->point_col);
 234          while (p >= buf && !isblank (*p))
 235            --p;
 236          nextline = p + 1;     /* This will begin the next line.  */
 237
 238          if (nextline > buf)
 239            {
 240              /* Swallow separating blanks.  */
 241              if (p >= buf)
 242                do
 243                  --p;
 244                while (p >= buf && isblank (*p));
 245              nl = p + 1;       /* The newline will replace the first blank. */
 246            }
 247          else
 248            {
 249              /* A single word that is greater than the maximum line width.
 250                 Oh well.  Put it on an overlong line by itself.  */
 251              p = buf + (r + 1 - fs->point_col);
 252              /* Find the end of the long word.  */
 253              do
 254                ++p;
 255              while (p < nl && !isblank (*p));
 256              if (p == nl)
 257                {
 258                  /* It already ends a line.  No fussing required.  */
 259                  fs->point_col = 0;
 260                  buf = nl + 1;
 261                  continue;
 262                }
 263              /* We will move the newline to replace the first blank.  */
 264              nl = p;
 265              /* Swallow separating blanks.  */
 266              do
 267                ++p;
 268              while (isblank (*p));
 269              /* The next line will start here.  */
 270              nextline = p;
 271            }
 272
 273          /* Note: There are a bunch of tests below for
 274             NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
 275             at the end of the buffer, and NEXTLINE is in fact empty (and so
 276             we need not be careful to maintain its contents).  */
 277
 278          if ((nextline == buf + len + 1
 279               ? fs->end - nl < fs->wmargin + 1
 280               : nextline - (nl + 1) < fs->wmargin)
 281              && fs->p > nextline)
 282            {
 283              /* The margin needs more blanks than we removed.  */
 284              if (fs->end - fs->p > fs->wmargin + 1)
 285                /* Make some space for them.  */
 286                {
 287                  size_t mv = fs->p - nextline;
 288                  memmove (nl + 1 + fs->wmargin, nextline, mv);
 289                  nextline = nl + 1 + fs->wmargin;
 290                  len = nextline + mv - buf;
 291                  *nl++ = '\n';
 292                }
 293              else
 294                /* Output the first line so we can use the space.  */
 295                {
 296 #if defined _LIBC && defined USE_IN_LIBIO
 297                  __fxprintf (fs->stream, "%.*s\n",
 298                              (int) (nl - fs->buf), fs->buf);
 299 #else
 300                  if (nl > fs->buf)
 301                    fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
 302                  putc_unlocked ('\n', fs->stream);
 303 #endif
 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
 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 #if defined _LIBC && defined USE_IN_LIBIO
 364       __fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
 365       wrote = fs->p - fs->buf;
 366 #else
 367       wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
 368 #endif
 369       if (wrote == fs->p - fs->buf)
 370        {
 371          fs->p = fs->buf;
 372          fs->point_offs = 0;
 373        }
 374       else
 375        {
 376          fs->p -= wrote;
 377          fs->point_offs -= wrote;
 378          memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
 379          return 0;
 380        }
 381
 382       if ((size_t) (fs->end - fs->buf) < amount)
 383        /* Gotta grow the buffer.  */
 384        {
 385          size_t old_size = fs->end - fs->buf;
 386          size_t new_size = old_size + amount;
 387          char *new_buf;
 388
 389          if (new_size < old_size || ! (new_buf = realloc (fs->buf, new_size)))
 390            {
 391              __set_errno (ENOMEM);
 392              return 0;
 393            }
 394
 395          fs->buf = new_buf;
 396          fs->end = new_buf + new_size;
 397          fs->p = fs->buf;
 398        }
 399     }
 400
 401   return 1;
 402 }
 403
 404 ssize_t
 405 __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
 406 {
 407   int out;
 408   size_t avail;
 409   size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
 410
 411   do
 412     {
 413       va_list args;
 414
 415       if (! __argp_fmtstream_ensure (fs, size_guess))
 416        return -1;
 417
 418       va_start (args, fmt);
 419       avail = fs->end - fs->p;
 420       out = __vsnprintf (fs->p, avail, fmt, args);
 421       va_end (args);
 422       if ((size_t) out >= avail)
 423        size_guess = out + 1;
 424     }
 425   while ((size_t) out >= avail);
 426
 427   fs->p += out;
 428
 429   return out;
 430 }
 431 #if 0
 432 /* Not exported.  */
 433 #ifdef weak_alias
 434 weak_alias (__argp_fmtstream_printf, argp_fmtstream_printf)
 435 #endif
 436 #endif
 437
 438 #endif /* !ARGP_FMTSTREAM_USE_LINEWRAP */