argp/argp-fmtstream.c

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