xref: /illumos-gate/usr/src/cmd/deroff/deroff.c (revision 2a8bcb4e)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <sys/varargs.h>

/*
 * Deroff command -- strip troff, eqn, and Tbl sequences from a file.
 * Has three flags argument, -w, to cause output one word per line
 * rather than in the original format.
 * -mm (or -ms) causes the corresponding macro's to be interpreted
 * so that just sentences are output
 * -ml  also gets rid of lists.
 * -i causes deroff to ignore .so and .nx commands.
 * Deroff follows .so and .nx commands, removes contents of macro
 * definitions, equations (both .EQ ... .EN and $...$),
 * Tbl command sequences, and Troff backslash constructions.
 *
 * All input is through the C macro; the most recently read character
 * is in c.
 */

#define	C	((c = getc(infile)) == EOF ? eof() : \
		    ((c == ldelim) && (filesp == files) ? skeqn() : c))
#define	C1	((c = getc(infile)) == EOF ? eof() : c)
#define	SKIP	while (C != '\n')
#define	SKIP_TO_COM	SKIP; SKIP; pc = c; \
			while ((C != '.') || (pc != '\n') || \
			    (C > 'Z')) { \
				pc = c; \
			}

#define	YES 1
#define	NO 0
#define	MS 0
#define	MM 1
#define	ONE 1
#define	TWO 2

#define	NOCHAR -2
#define	SPECIAL 0
#define	APOS 1
#define	DIGIT 2
#define	LETTER 3

#define	MAXLINESZ	512

static int wordflag = NO;
static int msflag = NO;
static int iflag = NO;
static int mac = MM;
static int disp = 0;
static int inmacro = NO;
static int intable = NO;
static int lindx;
static size_t linesize = MAXLINESZ;

static char chars[128];  /* SPECIAL, APOS, DIGIT, or LETTER */

static char *line = NULL;

static char c;
static int pc;
static int ldelim	= NOCHAR;
static int rdelim	= NOCHAR;

static int argc;
static char **argv;

extern int optind;
extern char *optarg;
static char fname[50];
static FILE *files[15];
static FILE **filesp;
static FILE *infile;

static void backsl(void);
static void comline(void);
static char *copys(char *);
static int eof(void);
static void eqn(void);
static void fatal(const char *, ...);
static void fatal_msg(char *);
static void getfname(void);
static void macro(void);
static FILE *opn(char *);
static void putmac(char *, int);
static void putwords(int);
static void regline(int, int);
static void sce(void);
static int skeqn(void);
static void sdis(char, char);
static void stbl(void);
static void tbl(void);
static void usage(void);
static void work(void)	__NORETURN;

int
main(int ac, char **av)
{
	int i;
	int errflg = 0;
	int optchar;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);
	argc = ac;
	argv = av;
	while ((optchar = getopt(argc, argv, "wim:")) != EOF) {
		switch (optchar) {
		case 'w':
			wordflag = YES;
			break;
		case 'm':
			msflag = YES;
			if (*optarg == 'm')
				mac = MM;
			else if (*optarg == 's')
				mac = MS;
			else if (*optarg == 'l')
				disp = 1;
			else
				errflg++;
			break;
		case 'i':
			iflag = YES;
			break;
		case '?':
			errflg++;
		}
	}
	if (errflg) {
		usage();
		return (1);
	}
	if (optind == argc)
		infile = stdin;
	else
		infile = opn(argv[optind++]);
	files[0] = infile;
	filesp = &files[0];

	for (i = 'a'; i <= 'z'; ++i)
		chars[i] = LETTER;
	for (i = 'A'; i <= 'Z'; ++i)
		chars[i] = LETTER;
	for (i = '0'; i <= '9'; ++i)
		chars[i] = DIGIT;
	chars['\''] = APOS;
	chars['&'] = APOS;
	work();
	/* NOTREACHED */
}


static int
skeqn(void)
{
	while ((c = getc(infile)) != rdelim) {
		if (c == EOF) {
			c = eof();
		} else if (c == '"') {
			while ((c = getc(infile)) != '"') {
				if (c == EOF) {
					c = eof();
				} else if (c == '\\') {
					if ((c = getc(infile)) == EOF) {
						c = eof();
					}
				}
			}
		}
	}
	if (msflag) {
		return (c = 'x');
	}
	return (c = ' ');
}


/* Functions calling opn() should ensure 'p' is non-null */
static FILE *
opn(char *p)
{
	FILE *fd;

	assert(p != NULL);
	if ((fd = fopen(p, "r")) == NULL)
		fatal(gettext("Cannot open file %s: %s\n"), p, strerror(errno));

	return (fd);
}



static int
eof(void)
{
	if (infile != stdin)
		(void) fclose(infile);
	if (filesp > files) {
		infile = *--filesp;
	} else if (optind < argc) {
		infile = opn(argv[optind++]);
	} else {
		exit(0);
	}

	return (C);
}



static void
getfname(void)
{
	char *p;
	struct chain {
		struct chain *nextp;
		char *datap;
	};
	struct chain *q;
	static struct chain *namechain = NULL;

	while (C == ' ')
		;

	for (p = fname; ((*p = c) != '\n') && (c != ' ') && (c != '\t') &&
	    (c != '\\'); ++p) {
		(void) C;
	}
	*p = '\0';
	while (c != '\n') {
		(void) C;
	}

	/* see if this name has already been used */
	for (q = namechain; q; q = q->nextp)
		if (strcmp(fname, q->datap) != 0) {
			fname[0] = '\0';
			return;
		}

	q = (struct chain *)calloc(1, sizeof (*namechain));
	q->nextp = namechain;
	q->datap = copys(fname);
	namechain = q;
}


/*
 * Functions calling fatal() should ensure 'format' and
 * arguments are non-null.
 */
static void
fatal(const char *format, ...)
{
	va_list	alist;

	assert(format != NULL);
	(void) fputs(gettext("deroff: "), stderr);
	va_start(alist, format);
	(void) vfprintf(stderr, format, alist);
	exit(1);
}

/* Functions calling fatal_msg() should ensure 's' is non-null */
static void
fatal_msg(char *s)
{
	assert(s != NULL);
	(void) fprintf(stderr, gettext("deroff: %s\n"), s);
	exit(1);
}

static void
usage(void)
{
	(void) fputs(gettext(
	    "usage: deroff [ -w ] [ -m (m s l) ] [ -i ] "
	    "[ file ] ... \n"), stderr);
}

static void
work(void)
{

	for (;;) {
		if ((C == '.') || (c == '\''))
			comline();
		else
			regline(NO, TWO);
	}
}


static void
regline(int macline, int cnst)
{

	if (line == NULL) {
		if ((line = (char *)malloc(linesize * sizeof (char))) == NULL) {
			fatal_msg(gettext("Cannot allocate memory"));
		}
	}

	lindx = 0;
	line[lindx] = c;
	for (;;) {
		if (c == '\\') {
			line[lindx] = ' ';
			backsl();
			if (c == '%') {	/* no blank for hyphenation char */
				lindx--;
			}
		}
		if (c == '\n') {
			break;
		}
		/*
		 * We're just about to add another character to the line
		 * buffer so ensure we don't overrun it.
		 */
		if (++lindx >= linesize - 1) {
			linesize = linesize * 2;
			if ((line = (char *)realloc(line,
			    linesize * sizeof (char))) == NULL) {
				fatal_msg(gettext("Cannot allocate memory"));
			}
		}
		if (intable && (c == 'T')) {
			line[lindx] = C;
			if ((c == '{') || (c == '}')) {
				line[lindx - 1] = ' ';
				line[lindx] = C;
			}
		} else {
			line[lindx] = C;
		}
	}

	line[lindx] = '\0';

	if (line[0] != '\0') {
		if (wordflag) {
			putwords(macline);
		} else if (macline) {
			putmac(line, cnst);
		} else {
			(void) puts(line);
		}
	}
}




static void
putmac(char *s, int cnst)
{
	char *t;

	while (*s) {
		while ((*s == ' ') || (*s == '\t')) {
			(void) putchar(*s++);
		}
		for (t = s; (*t != ' ') && (*t != '\t') && (*t != '\0'); ++t)
			;
		if (*s == '\"')
			s++;
		if ((t > s + cnst) && (chars[s[0]] == LETTER) &&
		    (chars[s[1]] == LETTER)) {
			while (s < t) {
				if (*s == '\"')
					s++;
				else
					(void) putchar(*s++);
			}
		} else {
			s = t;
		}
	}
	(void) putchar('\n');
}



static void
putwords(int macline)	/* break into words for -w option */
{
	char *p, *p1;
	int i, nlet;

	for (p1 = line; ; ) {
		/* skip initial specials ampersands and apostrophes */
		while (chars[*p1] < DIGIT) {
			if (*p1++ == '\0')
				return;
		}
		nlet = 0;
		for (p = p1; (i = chars[*p]) != SPECIAL; ++p) {
			if (i == LETTER)
				++nlet;
		}

		if ((!macline && (nlet > 1)) /* MDM definition of word */ ||
		    (macline && (nlet > 2) && (chars[p1[0]] == LETTER) &&
		    (chars[p1[1]] == LETTER))) {
			/* delete trailing ampersands and apostrophes */
			while ((p[-1] == '\'') || (p[-1] == '&')) {
				--p;
			}
			while (p1 < p) {
				(void) putchar(*p1++);
			}
			(void) putchar('\n');
		} else {
			p1 = p;
		}
	}
}



static void
comline(void)
{
	int c1, c2;

com:
	while ((C == ' ') || (c == '\t'))
		;
comx:
	if ((c1 = c) == '\n')
		return;
	c2 = C;
	if ((c1 == '.') && (c2 != '.'))
		inmacro = NO;
	if (c2 == '\n')
		return;

	if ((c1 == 'E') && (c2 == 'Q') && (filesp == files)) {
		eqn();
	} else if ((c1 == 'T') && ((c2 == 'S') || (c2 == 'C') ||
	    (c2 == '&')) && (filesp == files)) {
		if (msflag) {
			stbl();
		} else {
			tbl();
		}
	} else if ((c1 == 'T') && (c2 == 'E')) {
		intable = NO;
	} else if (!inmacro && (c1 == 'd') && (c2 == 'e')) {
		macro();
	} else if (!inmacro && (c1 == 'i') && (c2 == 'g')) {
		macro();
	} else if (!inmacro && (c1 == 'a') && (c2 == 'm')) {
		macro();
	} else if ((c1 == 's') && (c2 == 'o')) {
		if (iflag) {
			SKIP;
		} else {
			getfname();
			if (fname[0]) {
				infile = *++filesp = opn(fname);
			}
		}
	} else if ((c1 == 'n') && (c2 == 'x')) {
		if (iflag) {
			SKIP;
		} else {
			getfname();
			if (fname[0] == '\0') {
				exit(0);
			}
			if (infile != stdin) {
				(void) fclose(infile);
			}
			infile = *filesp = opn(fname);
		}
	} else if ((c1 == 'h') && (c2 == 'w')) {
		SKIP;
	} else if (msflag && (c1 == 'T') && (c2 == 'L')) {
		SKIP_TO_COM;
		goto comx;
	} else if (msflag && (c1 == 'N') && (c2 == 'R')) {
		SKIP;
	} else if (msflag && (c1 == 'A') && ((c2 == 'U') || (c2 == 'I'))) {
		if (mac == MM) {
			SKIP;
		} else {
			SKIP_TO_COM;
			goto comx;
		}
	} else if (msflag && (c1 == 'F') && (c2 == 'S')) {
		SKIP_TO_COM;
		goto comx;
	} else if (msflag && (c1 == 'S') && (c2 == 'H')) {
		SKIP_TO_COM;
		goto comx;
	} else if (msflag && (c1 == 'N') && (c2 == 'H')) {
		SKIP_TO_COM;
		goto comx;
	} else if (msflag && (c1 == 'O') && (c2 == 'K')) {
		SKIP_TO_COM;
		goto comx;
	} else if (msflag && (c1 == 'N') && (c2 == 'D')) {
		SKIP;
	} else if (msflag && (mac == MM) && (c1 == 'H') &&
	    ((c2 == ' ') || (c2 == 'U'))) {
		SKIP;
	} else if (msflag && (mac == MM) && (c2 == 'L')) {
		if (disp || (c1 == 'R')) {
			sdis('L', 'E');
		} else {
			SKIP;
			(void) putchar('.');
		}
	} else if (msflag && ((c1 == 'D') || (c1 == 'N') ||
	    (c1 == 'K') || (c1 == 'P')) && (c2 == 'S')) {
		sdis(c1, 'E');		/* removed RS-RE */
	} else if (msflag && (c1 == 'K' && c2 == 'F')) {
		sdis(c1, 'E');
	} else if (msflag && (c1 == 'n') && (c2 == 'f')) {
		sdis('f', 'i');
	} else if (msflag && (c1 == 'c') && (c2 == 'e')) {
		sce();
	} else {
		if ((c1 == '.') && (c2 == '.')) {
			while (C == '.')
				;
		}
		++inmacro;
		if ((c1 <= 'Z') && msflag) {
			regline(YES, ONE);
		} else {
			regline(YES, TWO);
		}
		--inmacro;
	}
}



static void
macro(void)
{
	if (msflag) {
		/* look for  .. */
		do {
			SKIP;
		} while ((C != '.') || (C != '.') || (C == '.'));
		if (c != '\n') {
			SKIP;
		}
		return;
	}
	SKIP;
	inmacro = YES;
}




static void
sdis(char a1, char a2)
{
	int c1, c2;
	int eqnf;
	int notdone = 1;
	eqnf = 1;
	SKIP;
	while (notdone) {
		while (C != '.')
			SKIP;
		if ((c1 = C) == '\n')
			continue;
		if ((c2 = C) == '\n')
			continue;
		if ((c1 == a1) && (c2 == a2)) {
			SKIP;
			if (eqnf)
				(void) putchar('.');
			(void) putchar('\n');
			return;
		} else if ((a1 == 'D') && (c1 == 'E') && (c2 == 'Q')) {
			eqn();
			eqnf = 0;
		} else {
			SKIP;
		}
	}
}

static void
tbl(void)
{
	while (C != '.')
		;
	SKIP;
	intable = YES;
}

static void
stbl(void)
{
	while (C != '.')
		;
	SKIP_TO_COM;
	if ((c != 'T') || (C != 'E')) {
		SKIP;
		pc = c;
		while ((C != '.') || (pc != '\n') ||
		    (C != 'T') || (C != 'E')) {
			pc = c;
		}
	}
}

static void
eqn(void)
{
	int c1, c2;
	int dflg;
	int last;

	last = 0;
	dflg = 1;
	SKIP;

	for (;;) {
		if ((C1 == '.') || (c == '\'')) {
			while ((C1 == ' ') || (c == '\t'))
				;
			if ((c == 'E') && (C1 == 'N')) {
				SKIP;
				if (msflag && dflg) {
					(void) putchar('x');
					(void) putchar(' ');
					if (last) {
						(void) putchar('.');
						(void) putchar(' ');
					}
				}
				return;
			}
		} else if (c == 'd') {	/* look for delim */
			if ((C1 == 'e') && (C1 == 'l')) {
				if ((C1 == 'i') && (C1 == 'm')) {
					while (C1 == ' ')
						;
					if (((c1 = c) == '\n') ||
					    ((c2 = C1) == '\n') ||
					    ((c1 == 'o') && (c2 == 'f') &&
					    (C1 == 'f'))) {
						ldelim = NOCHAR;
						rdelim = NOCHAR;
					} else {
						ldelim = c1;
						rdelim = c2;
					}
				}
				dflg = 0;
			}
		}

		if (c != '\n') {
			while (C1 != '\n') {
				if (c == '.') {
					last = 1;
				} else {
					last = 0;
				}
			}
		}
	}
}



static void
backsl(void)	/* skip over a complete backslash construction */
{
	int bdelim;

sw:	switch (C) {
	case '"':
		SKIP;
		return;
	case 's':
		if (C == '\\') {
			backsl();
		} else {
			while ((C >= '0') && (c <= '9'))
				;
			(void) ungetc(c, infile);
			c = '0';
		}
		lindx--;
		return;

	case 'f':
	case 'n':
	case '*':
		if (C != '(')
			return;
		/* FALLTHROUGH */

	case '(':
		if (C != '\n') {
			(void) C;
		}
		return;

	case '$':
		(void) C;	/* discard argument number */
		return;

	case 'b':
	case 'x':
	case 'v':
	case 'h':
	case 'w':
	case 'o':
	case 'l':
	case 'L':
		if ((bdelim = C) == '\n')
			return;
		while ((C != '\n') && (c != bdelim))
			if (c == '\\')
				backsl();
		return;

	case '\\':
		if (inmacro)
			goto sw;
	default:
		return;
	}
}




static char *
copys(char *s)
{
	char *t, *t0;

	if ((t0 = t = calloc((unsigned)(strlen(s) + 1), sizeof (*t))) == NULL)
		fatal_msg(gettext("Cannot allocate memory"));

	while (*t++ = *s++)
		;
	return (t0);
}

static void
sce(void)
{
	char *ap;
	int n, i;
	char a[10];

	for (ap = a; C != '\n'; ap++) {
		*ap = c;
		if (ap == &a[9]) {
			SKIP;
			ap = a;
			break;
		}
	}
	if (ap != a) {
		n = atoi(a);
	} else {
		n = 1;
	}
	for (i = 0; i < n; ) {
		if (C == '.') {
			if (C == 'c') {
				if (C == 'e') {
					while (C == ' ')
						;
					if (c == '0') {
						break;
					} else {
						SKIP;
					}
				} else {
					SKIP;
				}
			} else {
				SKIP;
			}
		} else {
			SKIP;
			i++;
		}
	}
}