contrib/cpio/lib/argp-fmtstream.c

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