/*	$OpenBSD: fmt.c,v 1.36 2016/01/07 18:02:43 schwarze 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

 */

#include <ctype.h>

#include <err.h>

#include <locale.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.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;

		else

	}

	}

}

/* 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 = 0;		/* Ditto, when squashing leading spaces */

static const char *sentence_enders = ".?!";	/* 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. */

static size_t x;				/* Horizontal position in output line */

static size_t x0;				/* Ditto, ignoring leading whitespace */

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 char *);

static int	might_be_header(const char *);

static void	new_paragraph(size_t);

static void	output_word(size_t, size_t, const char *, int, int, int);

static void	output_indent(size_t);

static void	center_stream(FILE *, const char *);

static char	*get_line(FILE *);

static void	*xrealloc(void *, size_t);

void		usage(void);

#define ERRS(x) (x >= 127 ? 127 : ++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 */

	/* 1. Grok parameters. */

		case 'c':

		case 'd':

		case 'l':

				= get_positive(optarg, "output tab width must be positive", 1);

		case 'm':

		case 'n':

		case 'p':

		case 's':

		case 't':

		case 'w':

		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() */

				char *p;

				else

							"width must be nonzero", 1);

			}

			break;

		case 'h':

		default:

			/* NOT REACHED */

		}

	}

	/* [ goal [ maximum ] ] */

	    (goal_length = get_positive(*argv,"goal length must be positive", 0)) != 0) {

		}

	}

	/* 2. Process files. */

	} else {

	}

	/* We're done. */

}

/* Process a single file, given its name.

 */

static void

process_named_file(const char *name)

{

	FILE *f;

	} else {

	}

}

/* 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)

{

	const char *wordp, *cp;

	wchar_t wc;

	size_t np;

	int wcl;			/* number of bytes in wide character */

	int wcw;			/* display width of wide character */

	int word_length;		/* number of bytes in word */

	int word_width;			/* display width of word */

	int space_width;		/* display width of space after word */

	int line_width;			/* display width of line */

	HdrType header_type;

	/* ^-- header_type of previous line; -1 at para start */

	const char *line;

	}

		}

		/* We need a new paragraph if and only if:

		 *   this line is blank,

		 *   OR it's a troff request,

		 *   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.

		 */

		    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)) ) {

			/* nroff compatibility */

			}

			} else {

				/* If this is an indented paragraph other than a mail header

				 * continuation, set |last_indent|.

				 */

			}

		}

					    tab_width - line_width;

					/* Skip whitespace at start of line. */

					}

					/* Count whitespace after word. */

				} else {

					/* Detect end of word. */

					/* Measure word. */

				}

			}

			/* Send the word to the output machinery. */

			    word_length, word_width, space_width);

		}

	}

	}

}

/* How long is the indent on this line?

 */

static size_t

indent_length(const char *line)

{

	for (;;) {

		case ' ':

		case '\t':

		default:

			break;

		}

		break;

	}

}

/* 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 char *line)

{

}

/* Begin a new paragraph with an indent of |indent| spaces.

 */

static void

new_paragraph(size_t indent)

{

}

/* Output spaces or tabs for leading indentation.

 */

static void

output_indent(size_t n_spaces)

{

		}

	}

}

/* Output a single word.

 * 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 char *word,

    int length, int width, int spaces)

{

	/* 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.

	 */

	    (new_x > goal_length && new_x-goal_length > goal_length-x)) {

	} else {

	}

}

/* Process a stream, but just center its lines rather than trying to

 * format them neatly.

 */

static void

center_stream(FILE *stream, const char *name)

{

	char *line, *cp;

	wchar_t wc;

	size_t l;	/* Display width of the line. */

	int wcw;	/* Display width of one character. */

	int wcl;	/* Length in bytes of one character. */

			else

		}

		}

	}

	}

}

/* Get a single line from a stream.  Strip control

 * characters and trailing whitespace, and handle backspaces.

 * Return the address of the buffer containing the line.

 * 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 NULL.

 */

static char *

get_line(FILE *stream)

{

	int ch;

	static char *buf = NULL;

	static size_t length = 0;

	}

			}

		}

	}

}

/* (Re)allocate some memory, exiting with an error if we can't.

 */

static void *

xrealloc(void *ptr, size_t nbytes)

{

	void *p;

}

void

usage(void)

{

	extern char *__progname;

		"usage: %s [-cmnps] [-d chars] [-l number] [-t number]\n"

		"\t[goal [maximum] | -width | -w width] [file ...]\n",

			__progname);

}