Import macOS userland

adv_cmds-176
basic_cmds-55
bootstrap_cmds-116.100.1
developer_cmds-66
diskdev_cmds-667.40.1
doc_cmds-53.60.1
file_cmds-321.40.3
mail_cmds-35
misc_cmds-34
network_cmds-606.40.1
patch_cmds-17
remote_cmds-63
shell_cmds-216.60.1
system_cmds-880.60.2
text_cmds-106

2 files changed, 864 insertions, 0 deletions

diff --git a/text_cmds/fmt/fmt.1 b/text_cmds/fmt/fmt.1
new file mode 100644
index 0000000..6480c82
--- /dev/null
+++ b/text_cmds/fmt/fmt.1
@@ -0,0 +1,196 @@
+.\" Copyright (c) 1980, 1990, 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"	This product includes software developed by the University of
+.\"	California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"     @(#)fmt.1	8.1 (Berkeley) 6/6/93
+.\" $FreeBSD: src/usr.bin/fmt/fmt.1,v 1.14 2004/08/02 11:12:13 tjr Exp $
+.\"
+.\" Modified by Gareth McCaughan to describe the new version of `fmt'
+.\" rather than the old one.
+.Dd August 2, 2004
+.Dt FMT 1
+.Os
+.Sh NAME
+.Nm fmt
+.Nd simple text formatter
+.Sh SYNOPSIS
+.Nm fmt
+.Op Fl cmnps
+.Op Fl d Ar chars
+.Op Fl l Ar num
+.Op Fl t Ar num
+.Op Ar goal Oo Ar maximum Oc | Fl Ns Ar width | Fl w Ar width
+.Op Ar
+.Sh DESCRIPTION
+The
+.Nm
+utility is a simple text formatter which reads the concatenation of input
+files (or standard input if none are given) and produces on standard
+output a version of its input with lines as close to the
+.Ar goal
+length
+as possible without exceeding the
+.Ar maximum .
+The
+.Ar goal
+length defaults
+to 65 and the
+.Ar maximum
+to 10 more than the
+.Ar goal
+length.
+Alternatively, a single
+.Ar width
+parameter can be specified either by prepending a hyphen to it or by using
+.Fl w .
+For example,
+.Dq Li fmt -w 72 ,
+.Dq Li fmt -72 ,
+and
+.Dq Li fmt 72 72
+all produce identical output.
+The spacing at the beginning of the input lines is preserved in the output,
+as are blank lines and interword spacing.
+Lines are joined or split only at white space; that is, words are never
+joined or hyphenated.
+.Pp
+The options are as follows:
+.Bl -tag -width indent
+.It Fl c
+Center the text, line by line.
+In this case, most of the other
+options are ignored; no splitting or joining of lines is done.
+.It Fl m
+Try to format mail header lines contained in the input sensibly.
+.It Fl n
+Format lines beginning with a
+.Ql \&.
+(dot) character.
+Normally,
+.Nm
+does not fill these lines, for compatibility with
+.Xr nroff 1 .
+.It Fl p
+Allow indented paragraphs.
+Without the
+.Fl p
+flag, any change in the amount of whitespace at the start of a line
+results in a new paragraph being begun.
+.It Fl s
+Collapse whitespace inside lines, so that multiple whitespace
+characters are turned into a single space.
+(Or, at the end of a
+sentence, a double space.)
+.It Fl d Ar chars
+Treat the
+.Ar chars
+(and no others) as sentence-ending characters.
+By default the
+sentence-ending characters are full stop
+.Pq Ql \&. ,
+question mark
+.Pq Ql \&?
+and exclamation mark
+.Pq Ql \&! .
+Remember that some characters may need to be
+escaped to protect them from your shell.
+.It Fl l Ar number
+Replace multiple spaces with tabs at the start of each output
+line, if possible.
+Each
+.Ar number
+spaces will be replaced with one tab.
+The default is 8.
+If
+.Ar number
+is 0, spaces are preserved.
+.It Fl t Ar number
+Assume that the input files' tabs assume
+.Ar number
+spaces per tab stop.
+The default is 8.
+.El
+.Pp
+The
+.Nm
+utility
+is meant to format mail messages prior to sending, but may also be useful
+for other simple tasks.
+For instance,
+within visual mode of the
+.Xr ex 1
+editor (e.g.,
+.Xr vi 1 )
+the command
+.Pp
+.Dl \&!}fmt
+.Pp
+will reformat a paragraph,
+evening the lines.
+.Sh ENVIRONMENT
+The
+.Ev LANG , LC_ALL
+and
+.Ev LC_CTYPE
+environment variables affect the execution of
+.Nm
+as described in
+.Xr environ 7 .
+.Sh SEE ALSO
+.Xr fold 1 ,
+.Xr mail 1 ,
+.Xr nroff 1
+.Sh HISTORY
+The
+.Nm
+command appeared in
+.Bx 3 .
+.Pp
+The version described herein is a complete rewrite and appeared in
+.Fx 4.4 .
+.Sh AUTHORS
+.An Kurt Shoens
+.An Liz Allen
+(added
+.Ar goal
+length concept)
+.An Gareth McCaughan
+.Sh BUGS
+The program was designed to be simple and fast \- for more complex
+operations, the standard text processors are likely to be more appropriate.
+.Pp
+When the first line of an indented paragraph is very long (more than
+about twice the goal length), the indentation in the output can be
+wrong.
+.Pp
+The
+.Nm
+utility is not infallible in guessing what lines are mail headers and what
+lines are not.
diff --git a/text_cmds/fmt/fmt.c b/text_cmds/fmt/fmt.c
new file mode 100644
index 0000000..853695f
--- /dev/null
+++ b/text_cmds/fmt/fmt.c
@@ -0,0 +1,668 @@
+/*	$OpenBSD: fmt.c,v 1.16 2000/06/25 15:35:42 pjanzen Exp $	*/
+
+/* Sensible version of fmt
+ *
+ * Syntax: fmt [ options ] [ goal [ max ] ] [ filename ... ]
+ *
+ * Since the documentation for the original fmt is so poor, here
+ * is an accurate description of what this one does. It's usually
+ * the same. The *mechanism* used may differ from that suggested
+ * here. Note that we are *not* entirely compatible with fmt,
+ * because fmt gets so many things wrong.
+ *
+ * 1. Tabs are expanded, assuming 8-space tab stops.
+ *    If the `-t <n>' option is given, we assume <n>-space
+ *    tab stops instead.
+ *    Trailing blanks are removed from all lines.
+ *    x\b == nothing, for any x other than \b.
+ *    Other control characters are simply stripped. This
+ *    includes \r.
+ * 2. Each line is split into leading whitespace and
+ *    everything else. Maximal consecutive sequences of
+ *    lines with the same leading whitespace are considered
+ *    to form paragraphs, except that a blank line is always
+ *    a paragraph to itself.
+ *    If the `-p' option is given then the first line of a
+ *    paragraph is permitted to have indentation different
+ *    from that of the other lines.
+ *    If the `-m' option is given then a line that looks
+ *    like a mail message header, if it is not immediately
+ *    preceded by a non-blank non-message-header line, is
+ *    taken to start a new paragraph, which also contains
+ *    any subsequent lines with non-empty leading whitespace.
+ *    Unless the `-n' option is given, lines beginning with
+ *    a . (dot) are not formatted.
+ * 3. The "everything else" is split into words; a word
+ *    includes its trailing whitespace, and a word at the
+ *    end of a line is deemed to be followed by a single
+ *    space, or two spaces if it ends with a sentence-end
+ *    character. (See the `-d' option for how to change that.)
+ *    If the `-s' option has been given, then a word's trailing
+ *    whitespace is replaced by what it would have had if it
+ *    had occurred at end of line.
+ * 4. Each paragraph is sent to standard output as follows.
+ *    We output the leading whitespace, and then enough words
+ *    to make the line length as near as possible to the goal
+ *    without exceeding the maximum. (If a single word would
+ *    exceed the maximum, we output that anyway.) Of course
+ *    the trailing whitespace of the last word is ignored.
+ *    We then emit a newline and start again if there are any
+ *    words left.
+ *    Note that for a blank line this translates as "We emit
+ *    a newline".
+ *    If the `-l <n>' option is given, then leading whitespace
+ *    is modified slightly: <n> spaces are replaced by a tab.
+ *    Indented paragraphs (see above under `-p') make matters
+ *    more complicated than this suggests. Actually every paragraph
+ *    has two `leading whitespace' values; the value for the first
+ *    line, and the value for the most recent line. (While processing
+ *    the first line, the two are equal. When `-p' has not been
+ *    given, they are always equal.) The leading whitespace
+ *    actually output is that of the first line (for the first
+ *    line of *output*) or that of the most recent line (for
+ *    all other lines of output).
+ *    When `-m' has been given, message header paragraphs are
+ *    taken as having first-leading-whitespace empty and
+ *    subsequent-leading-whitespace two spaces.
+ *
+ * Multiple input files are formatted one at a time, so that a file
+ * never ends in the middle of a line.
+ *
+ * There's an alternative mode of operation, invoked by giving
+ * the `-c' option. In that case we just center every line,
+ * and most of the other options are ignored. This should
+ * really be in a separate program, but we must stay compatible
+ * with old `fmt'.
+ *
+ * QUERY: Should `-m' also try to do the right thing with quoted text?
+ * QUERY: `-b' to treat backslashed whitespace as old `fmt' does?
+ * QUERY: Option meaning `never join lines'?
+ * QUERY: Option meaning `split in mid-word to avoid overlong lines'?
+ * (Those last two might not be useful, since we have `fold'.)
+ *
+ * Differences from old `fmt':
+ *
+ *   - We have many more options. Options that aren't understood
+ *     generate a lengthy usage message, rather than being
+ *     treated as filenames.
+ *   - Even with `-m', our handling of message headers is
+ *     significantly different. (And much better.)
+ *   - We don't treat `\ ' as non-word-breaking.
+ *   - Downward changes of indentation start new paragraphs
+ *     for us, as well as upward. (I think old `fmt' behaves
+ *     in the way it does in order to allow indented paragraphs,
+ *     but this is a broken way of making indented paragraphs
+ *     behave right.)
+ *   - Given the choice of going over or under |goal_length|
+ *     by the same amount, we go over; old `fmt' goes under.
+ *   - We treat `?' as ending a sentence, and not `:'. Old `fmt'
+ *     does the reverse.
+ *   - We return approved return codes. Old `fmt' returns
+ *     1 for some errors, and *the number of unopenable files*
+ *     when that was all that went wrong.
+ *   - We have fewer crashes and more helpful error messages.
+ *   - We don't turn spaces into tabs at starts of lines unless
+ *     specifically requested.
+ *   - New `fmt' is somewhat smaller and slightly faster than
+ *     old `fmt'.
+ *
+ * Bugs:
+ *
+ *   None known. There probably are some, though.
+ *
+ * Portability:
+ *
+ *   I believe this code to be pretty portable. It does require
+ *   that you have `getopt'. If you need to include "getopt.h"
+ *   for this (e.g., if your system didn't come with `getopt'
+ *   and you installed it yourself) then you should arrange for
+ *   NEED_getopt_h to be #defined.
+ *
+ *   Everything here should work OK even on nasty 16-bit
+ *   machines and nice 64-bit ones. However, it's only really
+ *   been tested on my FreeBSD machine. Your mileage may vary.
+ */
+
+/* Copyright (c) 1997 Gareth McCaughan. All rights reserved.
+ *
+ * Redistribution and use of this code, in source or binary forms,
+ * with or without modification, are permitted subject to the following
+ * conditions:
+ *
+ *  - Redistribution of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *  - If you distribute modified source code it must also include
+ *    a notice saying that it has been modified, and giving a brief
+ *    description of what changes have been made.
+ *
+ * Disclaimer: I am not responsible for the results of using this code.
+ *             If it formats your hard disc, sends obscene messages to
+ *             your boss and kills your children then that's your problem
+ *             not mine. I give absolutely no warranty of any sort as to
+ *             what the program will do, and absolutely refuse to be held
+ *             liable for any consequences of your using it.
+ *             Thank you. Have a nice day.
+ */
+
+/* RCS change log:
+ * Revision 1.5  1998/03/02 18:02:21  gjm11
+ * Minor changes for portability.
+ *
+ * Revision 1.4  1997/10/01 11:51:28  gjm11
+ * Repair broken indented-paragraph handling.
+ * Add mail message header stuff.
+ * Improve comments and layout.
+ * Make usable with non-BSD systems.
+ * Add revision display to usage message.
+ *
+ * Revision 1.3  1997/09/30 16:24:47  gjm11
+ * Add copyright notice, rcsid string and log message.
+ *
+ * Revision 1.2  1997/09/30 16:13:39  gjm11
+ * Add options: -d <chars>, -l <width>, -p, -s, -t <width>, -h .
+ * Parse options with `getopt'. Clean up code generally.
+ * Make comments more accurate.
+ *
+ * Revision 1.1  1997/09/30 11:29:57  gjm11
+ * Initial revision
+ */
+
+#ifndef lint
+static const char copyright[] =
+  "Copyright (c) 1997 Gareth McCaughan. All rights reserved.\n";
+#endif /* not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: src/usr.bin/fmt/fmt.c,v 1.22 2004/08/02 11:10:20 tjr Exp $");
+
+#include <err.h>
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wctype.h>
+
+/* Something that, we hope, will never be a genuine line length,
+ * indentation etc.
+ */
+#define SILLY ((size_t)-1)
+
+/* I used to use |strtoul| for this, but (1) not all systems have it
+ * and (2) it's probably better to use |strtol| to detect negative
+ * numbers better.
+ * If |fussyp==0| then we don't complain about non-numbers
+ * (returning 0 instead), but we do complain about bad numbers.
+ */
+static size_t
+get_positive(const char *s, const char *err_mess, int fussyP) {
+  char *t;
+  long result = strtol(s,&t,0);
+  if (*t) { if (fussyP) goto Lose; else return 0; }
+  if (result<=0) { Lose: errx(EX_USAGE, "%s", err_mess); }
+  return (size_t) result;
+}
+
+static size_t
+get_nonnegative(const char *s, const char *err_mess, int fussyP) {
+  char *t;
+  long result = strtol(s,&t,0);
+  if (*t) { if (fussyP) goto Lose; else return 0; }
+  if (result<0) { Lose: errx(EX_USAGE, "%s", err_mess); }
+  return (size_t) result;
+}
+
+/* Global variables */
+
+static int centerP=0;		/* Try to center lines? */
+static size_t goal_length=0;	/* Target length for output lines */
+static size_t max_length=0;	/* Maximum length for output lines */
+static int coalesce_spaces_P=0;	/* Coalesce multiple whitespace -> ' ' ? */
+static int allow_indented_paragraphs=0;	/* Can first line have diff. ind.? */
+static int tab_width=8;		/* Number of spaces per tab stop */
+static size_t output_tab_width=8;	/* Ditto, when squashing leading spaces */
+static const wchar_t *sentence_enders=L".?!";	/* Double-space after these */
+static int grok_mail_headers=0;	/* treat embedded mail headers magically? */
+static int format_troff=0;	/* Format troff? */
+
+static int n_errors=0;		/* Number of failed files. Return on exit. */
+static wchar_t *output_buffer=0;	/* Output line will be built here */
+static size_t x;		/* Horizontal position in output line */
+static size_t x0;		/* Ditto, ignoring leading whitespace */
+static size_t output_buffer_length = 0;
+static size_t pending_spaces;	/* Spaces to add before next word */
+static int output_in_paragraph=0;	/* Any of current para written out yet? */
+
+/* Prototypes */
+
+static void process_named_file (const char *);
+static void     process_stream (FILE *, const char *);
+static size_t    indent_length (const wchar_t *, size_t);
+static int     might_be_header (const wchar_t *);
+static void      new_paragraph (size_t, size_t);
+static void        output_word (size_t, size_t, const wchar_t *, size_t,
+				size_t);
+static void      output_indent (size_t);
+static void      center_stream (FILE *, const char *);
+static wchar_t *      get_line (FILE *, size_t *);
+static void *         xrealloc (void *, size_t);
+
+#define XMALLOC(x) xrealloc(0,x)
+
+/* Here is perhaps the right place to mention that this code is
+ * all in top-down order. Hence, |main| comes first.
+ */
+int
+main(int argc, char *argv[]) {
+  int ch;			/* used for |getopt| processing */
+  wchar_t *tmp;
+  size_t len;
+  const char *src;
+
+  (void) setlocale(LC_CTYPE, "");
+
+  /* 1. Grok parameters. */
+
+  while ((ch = getopt(argc, argv, "0123456789cd:hl:mnpst:w:")) != -1)
+  switch(ch) {
+    case 'c':
+      centerP = 1;
+      format_troff = 1;
+      continue;
+    case 'd':
+      src = optarg;
+      len = mbsrtowcs(NULL, &src, 0, NULL);
+      if (len == (size_t)-1)
+        err(EX_USAGE, "bad sentence-ending character set");
+      tmp = XMALLOC((len + 1) * sizeof(wchar_t));
+      mbsrtowcs(tmp, &src, len + 1, NULL);
+      sentence_enders = tmp;
+      continue;
+    case 'l':
+      output_tab_width
+        = get_nonnegative(optarg, "output tab width must be non-negative", 1);
+      continue;
+    case 'm':
+      grok_mail_headers = 1;
+      continue;
+    case 'n':
+      format_troff = 1;
+      continue;
+    case 'p':
+      allow_indented_paragraphs = 1;
+      continue;
+    case 's':
+      coalesce_spaces_P = 1;
+      continue;
+    case 't':
+      tab_width = get_positive(optarg, "tab width must be positive", 1);
+      continue;
+    case 'w':
+      goal_length = get_positive(optarg, "width must be positive", 1);
+      max_length = goal_length;
+      continue;
+    case '0': case '1': case '2': case '3': case '4': case '5':
+    case '6': case '7': case '8': case '9':
+    /* XXX  this is not a stylistically approved use of getopt() */
+      if (goal_length==0) {
+        char *p;
+        p = argv[optind - 1];
+        if (p[0] == '-' && p[1] == ch && !p[2])
+             goal_length = get_positive(++p, "width must be nonzero", 1);
+        else
+             goal_length = get_positive(argv[optind]+1,
+                 "width must be nonzero", 1);
+        max_length = goal_length;
+      }
+      continue;
+    case 'h': default:
+      fprintf(stderr,
+"usage:   fmt [-cmps] [-d chars] [-l num] [-t num]\n"
+"             [-w width | -width | goal [maximum]] [file ...]\n"
+"Options: -c     center each line instead of formatting\n"
+"         -d <chars> double-space after <chars> at line end\n"
+"         -l <n> turn each <n> spaces at start of line into a tab\n"
+"         -m     try to make sure mail header lines stay separate\n"
+"         -n     format lines beginning with a dot\n"
+"         -p     allow indented paragraphs\n"
+"         -s     coalesce whitespace inside lines\n"
+"         -t <n> have tabs every <n> columns\n"
+"         -w <n> set maximum width to <n>\n"
+"         goal   set target width to goal\n");
+      exit(ch=='h' ? 0 : EX_USAGE);
+  }
+  argc -= optind; argv += optind;
+
+  /* [ goal [ maximum ] ] */
+
+  if (argc>0 && goal_length==0
+      && (goal_length=get_positive(*argv,"goal length must be positive", 0))
+         != 0) {
+    --argc; ++argv;
+    if (argc>0
+        && (max_length=get_positive(*argv,"max length must be positive", 0))
+           != 0) {
+      --argc; ++argv;
+      if (max_length<goal_length)
+        errx(EX_USAGE, "max length must be >= goal length");
+    }
+  }
+  if (goal_length==0) goal_length = 65;
+  if (max_length==0) max_length = goal_length+10;
+  /* really needn't be longer */
+  output_buffer = XMALLOC((max_length+1) * sizeof(wchar_t));
+
+  /* 2. Process files. */
+
+  if (argc>0) {
+    while (argc-->0) process_named_file(*argv++);
+  }
+  else {
+    process_stream(stdin, "standard input");
+  }
+
+  /* We're done. */
+
+  return n_errors ? EX_NOINPUT : 0;
+
+}
+
+/* Process a single file, given its name.
+ */
+static void
+process_named_file(const char *name) {
+  FILE *f=fopen(name, "r");
+  if (!f) { warn("%s", name); ++n_errors; }
+  else {
+    process_stream(f, name);
+    if (ferror(f)) { warn("%s", name); ++n_errors; }
+    fclose(f);
+  }
+}
+
+/* Types of mail header continuation lines:
+ */
+typedef enum {
+  hdr_ParagraphStart = -1,
+  hdr_NonHeader      = 0,
+  hdr_Header         = 1,
+  hdr_Continuation   = 2
+} HdrType;
+
+/* Process a stream. This is where the real work happens,
+ * except that centering is handled separately.
+ */
+static void
+process_stream(FILE *stream, const char *name) {
+  size_t last_indent=SILLY;	/* how many spaces in last indent? */
+  size_t para_line_number=0;	/* how many lines already read in this para? */
+  size_t first_indent=SILLY;	/* indentation of line 0 of paragraph */
+  HdrType prev_header_type=hdr_ParagraphStart;
+	/* ^-- header_type of previous line; -1 at para start */
+  wchar_t *line;
+  size_t length;
+
+  if (centerP) { center_stream(stream, name); return; }
+  while ((line=get_line(stream,&length)) != NULL) {
+    size_t np=indent_length(line, length);
+    { HdrType header_type=hdr_NonHeader;
+      if (grok_mail_headers && prev_header_type!=hdr_NonHeader) {
+        if (np==0 && might_be_header(line))
+          header_type = hdr_Header;
+        else if (np>0 && prev_header_type>hdr_NonHeader)
+          header_type = hdr_Continuation;
+      }
+      /* We need a new paragraph if and only if:
+       *   this line is blank,
+       *   OR it's a troff request (and we don't format troff),
+       *   OR it's a mail header,
+       *   OR it's not a mail header AND the last line was one,
+       *   OR the indentation has changed
+       *      AND the line isn't a mail header continuation line
+       *      AND this isn't the second line of an indented paragraph.
+       */
+      if ( length==0
+           || (line[0]=='.' && !format_troff)
+           || header_type==hdr_Header
+           || (header_type==hdr_NonHeader && prev_header_type>hdr_NonHeader)
+           || (np!=last_indent
+               && header_type != hdr_Continuation
+               && (!allow_indented_paragraphs || para_line_number != 1)) ) {
+        new_paragraph(output_in_paragraph ? last_indent : first_indent, np);
+        para_line_number = 0;
+        first_indent = np;
+        last_indent = np;
+        if (header_type==hdr_Header) last_indent=2;	/* for cont. lines */
+        if (length==0 || (line[0]=='.' && !format_troff)) {
+          if (length==0)
+            putwchar('\n');
+          else
+            wprintf(L"%.*ls\n", (int)length, line);
+          prev_header_type=hdr_ParagraphStart;
+          continue;
+        }
+      }
+      else {
+        /* If this is an indented paragraph other than a mail header
+         * continuation, set |last_indent|.
+         */
+        if (np != last_indent && header_type != hdr_Continuation)
+          last_indent=np;
+      }
+      prev_header_type = header_type;
+    }
+
+    { size_t n=np;
+      while (n<length) {
+        /* Find word end and count spaces after it */
+        size_t word_length=0, space_length=0;
+        while (n+word_length < length && line[n+word_length] != ' ')
+          ++word_length;
+        space_length = word_length;
+        while (n+space_length < length && line[n+space_length] == ' ')
+          ++space_length;
+        /* Send the word to the output machinery. */
+        output_word(first_indent, last_indent,
+                    line+n, word_length, space_length-word_length);
+        n += space_length;
+      }
+    }
+    ++para_line_number;
+  }
+  new_paragraph(output_in_paragraph ? last_indent : first_indent, 0);
+  if (ferror(stream)) { warn("%s", name); ++n_errors; }
+}
+
+/* How long is the indent on this line?
+ */
+static size_t
+indent_length(const wchar_t *line, size_t length) {
+  size_t n=0;
+  while (n<length && *line++ == ' ') ++n;
+  return n;
+}
+
+/* Might this line be a mail header?
+ * We deem a line to be a possible header if it matches the
+ * Perl regexp /^[A-Z][-A-Za-z0-9]*:\s/. This is *not* the same
+ * as in RFC whatever-number-it-is; we want to be gratuitously
+ * conservative to avoid mangling ordinary civilised text.
+ */
+static int
+might_be_header(const wchar_t *line) {
+  if (!iswupper(*line++)) return 0;
+  while (*line && (iswalnum(*line) || *line=='-')) ++line;
+  return (*line==':' && iswspace(line[1]));
+}
+
+/* Begin a new paragraph with an indent of |indent| spaces.
+ */
+static void
+new_paragraph(size_t old_indent, size_t indent) {
+  if (output_buffer_length) {
+    if (old_indent>0) output_indent(old_indent);
+    wprintf(L"%.*ls\n", (int)output_buffer_length, output_buffer);
+  }
+  x=indent; x0=0; output_buffer_length=0; pending_spaces=0;
+  output_in_paragraph = 0;
+}
+
+/* Output spaces or tabs for leading indentation.
+ */
+static void
+output_indent(size_t n_spaces) {
+  if (output_tab_width) {
+    while (n_spaces >= output_tab_width) {
+      putwchar('\t');
+      n_spaces -= output_tab_width;
+    }
+  }
+  while (n_spaces-- > 0) putwchar(' ');
+}
+
+/* Output a single word, or add it to the buffer.
+ * indent0 and indent1 are the indents to use on the first and subsequent
+ * lines of a paragraph. They'll often be the same, of course.
+ */
+static void
+output_word(size_t indent0, size_t indent1, const wchar_t *word, size_t length, size_t spaces) {
+  size_t new_x;
+  size_t indent = output_in_paragraph ? indent1 : indent0;
+  size_t width;
+  const wchar_t *p;
+  int cwidth;
+
+  for (p = word, width = 0; p < &word[length]; p++)
+    width += (cwidth = wcwidth(*p)) > 0 ? cwidth : 1;
+
+  new_x = x + pending_spaces + width;
+
+  /* If either |spaces==0| (at end of line) or |coalesce_spaces_P|
+   * (squashing internal whitespace), then add just one space;
+   * except that if the last character was a sentence-ender we
+   * actually add two spaces.
+   */
+  if (coalesce_spaces_P || spaces==0)
+    spaces = wcschr(sentence_enders, word[length-1]) ? 2 : 1;
+
+  if (new_x<=goal_length) {
+    /* After adding the word we still aren't at the goal length,
+     * so clearly we add it to the buffer rather than outputing it.
+     */
+    wmemset(output_buffer+output_buffer_length, L' ', pending_spaces);
+    x0 += pending_spaces; x += pending_spaces;
+    output_buffer_length += pending_spaces;
+    wmemcpy(output_buffer+output_buffer_length, word, length);
+    x0 += width; x += width; output_buffer_length += length;
+    pending_spaces = spaces;
+  }
+  else {
+    /* Adding the word takes us past the goal. Print the line-so-far,
+     * and the word too iff either (1) the lsf is empty or (2) that
+     * makes us nearer the goal but doesn't take us over the limit,
+     * or (3) the word on its own takes us over the limit.
+     * In case (3) we put a newline in between.
+     */
+    if (indent>0) output_indent(indent);
+    wprintf(L"%.*ls", (int)output_buffer_length, output_buffer);
+    if (x0==0 || (new_x <= max_length && new_x-goal_length <= goal_length-x)) {
+      wprintf(L"%*ls", (int)pending_spaces, L"");
+      goto write_out_word;
+    }
+    else {
+      /* If the word takes us over the limit on its own, just
+       * spit it out and don't bother buffering it.
+       */
+      if (indent+width > max_length) {
+        putwchar('\n');
+        if (indent>0) output_indent(indent);
+write_out_word:
+        wprintf(L"%.*ls", (int)length, word);
+        x0 = 0; x = indent1; pending_spaces = 0;
+        output_buffer_length = 0;
+      }
+      else {
+        wmemcpy(output_buffer, word, length);
+        x0 = width; x = width+indent1; pending_spaces = spaces;
+        output_buffer_length = length;
+      }
+    }
+    putwchar('\n');
+    output_in_paragraph = 1;
+  }
+}
+
+/* Process a stream, but just center its lines rather than trying to
+ * format them neatly.
+ */
+static void
+center_stream(FILE *stream, const char *name) {
+  wchar_t *line, *p;
+  size_t length;
+  size_t width;
+  int cwidth;
+  while ((line=get_line(stream, &length)) != 0) {
+    size_t l=length;
+    while (l>0 && iswspace(*line)) { ++line; --l; }
+    length=l;
+    for (p = line, width = 0; p < &line[length]; p++)
+      width += (cwidth = wcwidth(*p)) > 0 ? cwidth : 1;
+    l = width;
+    while (l<goal_length) { putwchar(' '); l+=2; }
+    wprintf(L"%.*ls\n", (int)length, line);
+  }
+  if (ferror(stream)) { warn("%s", name); ++n_errors; }
+}
+
+/* Get a single line from a stream. Expand tabs, strip control
+ * characters and trailing whitespace, and handle backspaces.
+ * Return the address of the buffer containing the line, and
+ * put the length of the line in |lengthp|.
+ * This can cope with arbitrarily long lines, and with lines
+ * without terminating \n.
+ * If there are no characters left or an error happens, we
+ * return 0.
+ * Don't confuse |spaces_pending| here with the global
+ * |pending_spaces|.
+ */
+static wchar_t *
+get_line(FILE *stream, size_t *lengthp) {
+  static wchar_t *buf=NULL;
+  static size_t length=0;
+  size_t len=0;
+  wint_t ch;
+  size_t spaces_pending=0;
+  int troff=0;
+  size_t col=0;
+  int cwidth;
+
+  if (buf==NULL) { length=100; buf=XMALLOC(length * sizeof(wchar_t)); }
+  while ((ch=getwc(stream)) != '\n' && ch != WEOF) {
+    if (len+spaces_pending==0 && ch=='.' && !format_troff) troff=1;
+    if (ch==' ') ++spaces_pending;
+    else if (troff || iswprint(ch)) {
+      while (len+spaces_pending >= length) {
+        length*=2; buf=xrealloc(buf, length * sizeof(wchar_t));
+      }
+      while (spaces_pending > 0) { --spaces_pending; buf[len++]=' '; col++; }
+      buf[len++] = ch;
+      col += (cwidth = wcwidth(ch)) > 0 ? cwidth : 1;
+    }
+    else if (ch=='\t')
+      spaces_pending += tab_width - (col+spaces_pending)%tab_width;
+    else if (ch=='\b') { if (len) --len; if (col) --col; }
+  }
+  *lengthp=len;
+  return (len>0 || ch!=WEOF) ? buf : 0;
+}
+
+/* (Re)allocate some memory, exiting with an error if we can't.
+ */
+static void *
+xrealloc(void *ptr, size_t nbytes) {
+  void *p = realloc(ptr, nbytes);
+  if (p == NULL) errx(EX_OSERR, "out of memory");
+  return p;
+}