/* fmt.c */

/* usage: fmt [-width] [files]...
 *
 * Fmt rearrages text in order to make each line have roughly the
 * same width.  Indentation and word spacing is preserved.
 *
 * The default width is 72 characters, but you can override that via -width.
 * If no files are given on the command line, then it reads stdin.
 */

#include <stdio.h>

#ifndef TRUE
# define TRUE	1
# define FALSE	0
#endif

#define iswhite(c)	((c) == ' ' || (c) == '\t')


int	width = 72;	/* the desired line width */
int	isblankln;	/* is the current output line blank? */
int	indent;		/* width of the indentation */
char	ind[512];	/* indentation text */
char	word[1024];	/* word buffer */

/* This function displays a usage message and quits */
void usage()
{
	fprintf(stderr, "usage: fmt [-width] [files]...\n");
	exit(2);
}



/* This function outputs a single word.  It takes care of spacing and the
 * newlines within a paragraph.
 */
void putword()
{
	int		i;		/* index into word[], or whatever */
	int		ww;		/* width of the word */
	int		sw;		/* width of spacing after word */
	static int	psw;		/* space width of previous word */
	static int	tab;		/* the width of text already written */


	/* separate the word and its spacing */
	for (ww = 0; word[ww] && !iswhite(word[ww]); ww++)
	{
	}
	sw = strlen(word) - ww;
	word[ww] = '\0';

	/* if no spacing (that is, the word was at the end of the line) then
	 * assume 1 space unless the last char of the word was punctuation
	 */
	if (sw == 0)
	{
		sw = 1;
		if (word[ww - 1] == '.' || word[ww - 1] == '?' || word[ww - 1] == '!')
			sw = 2;
	}

	/* if this is the first word on the line... */
	if (isblankln)
	{
		/* output the indentation first */
		fputs(ind, stdout);
		tab = indent;
	}
	else /* text has already been written to this output line */
	{
		/* will the word fit on this line? */
		if (psw + ww + tab <= width)
		{
			/* yes - so write the previous word's spacing */
			for (i = 0; i < psw; i++)
			{
				putchar(' ');
			}
			tab += psw;
		}
		else
		{
			/* no, so write a newline and the indentation */
			putchar('\n');
			fputs(ind, stdout);
			tab = indent;
		}
	}

	/* write the word itself */
	fputs(word, stdout);
	tab += ww;

	/* remember this word's spacing */
	psw = sw;

	/* this output line isn't blank anymore. */
	isblankln = FALSE;
}



/* This function reformats text. */
void fmt(in)
	FILE	*in;		/* the input stream */
{
	int	ch;		/* character from input stream */
	int	prevch;		/* the previous character in the loop */
	int	i;		/* index into ind[] or word[] */
	int	inword;		/* boolean: are we between indent & newline? */


	/* for each character in the stream... */
	for (indent = -1, isblankln = TRUE, inword = FALSE, i = 0, prevch = '\n';
	     (ch = getc(in)) != EOF;
	     prevch = ch)
	{
		/* is this the end of a line? */
		if (ch == '\n')
		{
			/* if end of last word in the input line */
			if (inword)
			{
				/* if it really is a word */
				if (i > 0)
				{
					/* output it */
					word[i] = '\0';
					putword();
				}
			}
			else /* blank line in input */
			{
				/* finish the previous paragraph */
				if (!isblankln)
				{
					putchar('\n');
					isblankln = TRUE;
				}

				/* output a blank line */
				putchar('\n');
			}

			/* continue with next input line... */
			indent = -1;
			i = 0;
			inword = FALSE;
			continue;
		}

		/* if we're expecting indentation now... */
		if (indent < 0)
		{
			/* if this is part of the indentation... */
			if (iswhite(ch))
			{
				/* remember it */
				ind[i++] = ch;
			}
			else /* end of indentation */
			{
				/* mark the end of the indentation string */
				ind[i] = '\0';

				/* calculate the width of the indentation */
				for (i = indent = 0; ind[i]; i++)
				{
					if (ind[i] == '\t')
						indent = (indent | 7) + 1;
					else
						indent++;
				}

				/* reset the word index */
				i = 0;

				/* reprocess that last character */
				ungetc(ch, in);
			}

			/* continue in the for-loop */
			continue;
		}

		/* if we get here, we're either in a word or in the space
		 * after a word.
		 */
		inword = TRUE;

		/* is this the start of a new word? */
		if (!iswhite(ch) && iswhite(prevch))
		{
			/* yes!  output the previous word */
			word[i] = '\0';
			putword();

			/* reset `i' to the start of the word[] buffer */
			i = 0;
		}
		word[i++] = ch;
	}

	/* if necessary, write a final newline */
	if (!isblankln)
	{
		putchar('\n');
		isblankln = TRUE;
	}
}





int main(argc, argv)
	int	argc;
	char	**argv;
{
	FILE	*in;	/* an input stream */
	int	error;	/* if non-zero, then an error occurred */
	int	i;


#ifdef __EMX__
	/* expand command-line wildcards first */
	_wildcard(&argc, &argv);
#endif

	/* handle the -width flag, if given */
	if (argc > 1 && argv[1][0] == '-')
	{
		width = atoi(argv[1] + 1);
		if (width <= 0)
		{
			usage();
		}
		argc--;
		argv++;
	}

	/* for now, assume there are no errors */
	error = 0;

	/* if no filenames given, then process stdin */
	if (argc == 1)
	{
		fmt(stdin);
	}
	else /* one or more filenames given */
	{
		for (i = 1; i < argc; i++)
		{
			in = fopen(argv[i], "r");
			if (!in)
			{
				perror(argv[i]);
				error = 3;
			}
			else
			{
				fmt(in);
				fclose(in);
			}
		}
	}

	/* exit, possibly indicating an error */
	return error;
}
