argp/argp-fmtstream.c

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