🚀 go-pugleaf

Several people complained that part 2 of the Proff repost was truncated.
I didn't notice the problem here, but for those of you who did have trouble,
here is part 2 again, in 2 parts:


#! /bin/sh
# To extract, remove mail header lines and type "sh filename"
echo x - pinit.c
sed -e 's/^X//' > pinit.c << '!FaR!OuT!'
X#include <stdio.h>
X#include <ctype.h>
X#include "proff.h"
X#include "debug.h"
X
X/*
X * finit - initialise parameters, set default values
X *	   used by .reset command
X *
X */
Xfinit()
X{
X	int i;
X
X	inval = 0;
X	rmval = PAGEWIDTH;
X	tival = 0;
X	lsval = 1;
X	fill = YES;
X	ceval = 0;
X	ulval = 0;
X	boval = 0;
X	cchar = '.';
X	genesc = '_';
X	tjust[0] = LEFT;
X	tjust[1] = CENTER;
X	tjust[2] = RIGHT;
X	bsval = 0;
X	rjust = YES;
X	ulblnk = BLANK;
X
X	for (i = 0; i < INSIZE; i++)
X		if (i % 8 == 0)
X			tabs[i] = YES;
X		else
X			tabs[i] = NO;
X
X	lineno = 0;
X	curpag = 0;
X	newpag = 1;
X	plval = PAGELEN;
X	m1val = 3;
X	m2val = 2;
X	m3val = 2;
X	m4val = 3;
X	bottom = plval - m3val - m4val;
X	ehead[0] = '\n';
X	ehead[1] = EOS;
X	ohead[0] = '\n';
X	ohead[1] = EOS;
X	efoot[0] = '\n';
X	efoot[1] = EOS;
X	ofoot[0] = '\n';
X	ofoot[1] = EOS;
X	ehlim[0] = inval;
X	ehlim[1] = rmval;
X	ohlim[0] = inval;
X	ohlim[1] = rmval;
X	eflim[0] = inval;
X	eflim[1] = rmval;
X	oflim[0] = inval;
X	oflim[1] = rmval;
X	verbose = NO;   
X	stopx = 0;
X	frstpg = 0;
X	lastpg = HUGE;
X	print = YES;
X	offset = 0;
X	outp = 0;
X	outw = 0;
X	outwds = 0;
X	bp = -1;
X	for (i = 0; i < 26; i++)
X		nr[i] = 0;
X
X	CEon = FALSE;
X	ULon = FALSE;
X	BDon = FALSE;
X
X	onlyrunoff = FALSE;
X	roman = FALSE;
X	bolding = YES;
X	autopar = NO;
X}
!FaR!OuT!
echo x - proff.c
sed -e 's/^X//' > proff.c << '!FaR!OuT!'
Xchar *version = "v.1.1";
X
X#define GLOBALS 1
X
X#include <stdio.h>
X#include <ctype.h>
X#include "debug.h"
X#include "defs.h"
X#include "lookup.h"
X
X#define brk brrk
X
X/*
X * G L O B A L S
X *
X */
X#ifndef vms
X#define globaldef
X#endif
X
X	/* next available char; init = 0 */
Xglobaldef int bp = -1;
X	/* pushed-back characters */
Xglobaldef char buf[BUFSIZE];
X	/* stack of file descriptors */
Xglobaldef FILE *infile[NFILES];
X	/* current file is infile[level] */
Xglobaldef int level;
X	/* stack of output file descriptors */
Xglobaldef FILE *outfile[NFILES];
X	/* current output is outfile[olevel]; */
Xglobaldef int olevel;
X	/* current output file pointer */
Xglobaldef FILE *poutput;
X	/* number registers a..z */
Xglobaldef int nr[26] = {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
X			  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
X	/* system registers a..z */
Xglobaldef int sr[26] = {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
X			  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
X	/* last char position in outbuf; init = 0 */
Xglobaldef int outp = 0;
X	/* width of text currently in outbuf; init = 0 */
Xglobaldef int outw = 0;
X	/* number of words in outbuf; init = 0 */
Xglobaldef int outwds = 0;
X	/* lines to be filled collect here */
Xglobaldef char outbuf[MAXOUT];
X                       /* word in outbuf; init=0 */
X	/* current output page number; init = 0 */
Xglobaldef int curpag = 0;
X	/* next output page number; init = 1 */
Xglobaldef int newpag = 1;
X	/* next line to be printed; init = 0 */
Xglobaldef int lineno = 0;
X	/* page length in lines; init = PAGELEN = 66 */
Xglobaldef int plval = PAGELEN;
X	/* page length save area */
Xglobaldef int savpl = PAGELEN;
X	/* margin before and including header */
Xglobaldef int m1val = 3;
X	/* margin after header */
Xglobaldef int m2val = 2;
X	/* margin after last text line */
Xglobaldef int m3val = 2;
X	/* bottom margin, including footer */
Xglobaldef int m4val = 3;
X	/* last live line on page, = plval-m3val-m4val */
Xglobaldef int bottom = PAGELEN - 5;
X	/* top of page title for even pages;init=NEWLINE */
Xglobaldef char ehead[MAXLINE];
X	/* top of page title for odd  pages;init=NEWLINE */
Xglobaldef char ohead[MAXLINE];
X	/* left,right margins for even header;init=inval,rmval */
Xglobaldef int ehlim[2] = { 0, PAGEWIDTH };
X	/* left,right margins for odd  header;init=inval,rmval */
Xglobaldef int ohlim[2] = { 0, PAGEWIDTH };
X	/* bot of page title for even pages;init=NEWLINE */
Xglobaldef char efoot[MAXLINE];
X	/* bot of page title for odd  pages;init=NEWLINE */
Xglobaldef char ofoot[MAXLINE];
X	/* left,right margins for even footer;init=inval,rmval */
Xglobaldef int eflim[2] = { 0, PAGEWIDTH };
X	/* left,right margins for odd  footer;init=inval,rmval */
Xglobaldef int oflim[2] = { 0, PAGEWIDTH };
X	/* flag for pausing between pages */
Xglobaldef int stopx = 0;
X	/* first page to begin printing with */
Xglobaldef int frstpg = 0;
X	/* last page to be printed */
Xglobaldef int lastpg = HUGE;
X	/* flag to indicate whether page should be printed */
Xglobaldef int print = YES;
X	/* number of blanks to offset page by; init = 0 */
Xglobaldef int  offset = 0;
X	/* verbose option; init = NO */
Xglobaldef int verbose = NO;
X	/* bolding option; init = YES; */
Xglobaldef char bolding = YES;
X	/* fill if YES; init = YES */
Xglobaldef int fill = YES;
X	/* current line spacing; init = 1 */
Xglobaldef int lsval = 1;
X	/* current indent; >= 0; init = 0 */
Xglobaldef int inval = 0;
X	/* current right margin; init = PAGEWIDTH = 60 */
Xglobaldef int rmval = PAGEWIDTH;
X	/* current temporary indent; init = 0 */
Xglobaldef int tival = 0;
X	/* number of lines to center; init = 0 */
Xglobaldef int ceval = 0;
X	/* flag for continuous center */
Xglobaldef char CEon = FALSE;
X	/* number of lines to underline; init = 0 */
Xglobaldef int ulval = 0;
X	/* flag for continuous underline */
Xglobaldef char ULon = FALSE;
X	/* number of lines to boldface; init = 0 */
Xglobaldef int boval = 0;
X	/* flag for continuous bolding */
Xglobaldef char BDon = FALSE;
X	/* justification types for heads and foots; */
X	/* init = LEFT, CENTER, RIGHT */
Xglobaldef int tjust[3] = { LEFT, CENTER, RIGHT };  
X	/* number of lines to blank suppress; init=0 */
Xglobaldef int bsval = 0;
X	/* right justify filled lines if YES; init=YES */
Xglobaldef int rjust = YES;
X	/* tab stops; init every 8 spaces */
Xglobaldef int tabs[INSIZE];
X	/* line control character; init = PERIOD */
Xglobaldef char cchar = '.';
X	/* universal escape - init = UNDERBAR */
Xglobaldef char genesc = '_';
X	/* character used to underline a BLANK; init = BLANK */
Xglobaldef char ulblnk = ' ';
X	/* scratch arrays for use by various routines */
Xglobaldef char tbuf1[MAXLINE];
Xglobaldef char tbuf2[MAXLINE];
Xglobaldef char tbuf3[MAXLINE];
Xglobaldef char ttl[MAXLINE];
X	/* flag to process runoff symbols only */
Xglobaldef char onlyrunoff = NO;
X	/* Flag to turn paging off */
Xglobaldef char paging = YES;
X	/* page number in roman numerals. Init = NO */
Xglobaldef char roman = NO;
X	/* autopar flag. Init = NO */
Xglobaldef char autopar = NO;
X	/* temporary indent value for autopar */
Xglobaldef int autoprv = 5;
X	/* hash tables for macros and variables */
Xglobaldef struct hashlist *macrotab[HASHMAX];
Xglobaldef struct hashlist *gentab[HASHMAX];
X	/* linked list entries for contents	*/
Xglobaldef struct clist *chead = NULL;
Xglobaldef struct clist *clast = NULL;
X	/* keep track of what is done - VERBOSE */
Xglobaldef int p_txtlines = 0;
Xglobaldef int p_outlines = 0;
Xglobaldef int p_outpages = 0;
Xglobaldef int p_memoryus = 0;
X
X
X
X/*
X * M A I N L I N E   OF   P R O F F
X *
X */
X
Xmain(argc,argv)
Xint argc;
Xchar *argv[];
X{
X        int i,j,val,type;
X        char *p,c;
X        FILE *fp, *fopen();
X
X        for (i = 1; i < argc; i++) {
X                p = argv[i];
X                if (*p == '-') {
X                        ++p;
X                        if (isalpha(*p)) {
X                                c = *p++;
X                                switch(c) {
X
X/* verbose stats */		case 'v':
X				case 'V':
X					verbose = TRUE;
X					break;
X/* runoff only   */		case 'r':
X				case 'R':
X					onlyrunoff = TRUE;
X					break;
X/* stop for page */             case 's':
X                                case 'S':
X                                        stopx = 1;
X                                        break;
X/* page offset   */             case 'p':
X                                case 'P':
X                                        if (*p == 'o' || *p == 'O') {
X                                                p++;
X                                                j = 0;
X                                                val = getval(p, &j, &type);
X                                                set(&offset, val, type, 0, 0,
X                                                    rmval - 1);
X                                        }
X                                        else
X                                                usage();
X                                        break;
X/* include file  */ 		case 'i':
X				case 'I': /* simulate .so <filename> */
X					pbstr("\n");
X					pbstr(p);
X					pbstr(".so ");
X					break;
X
X/* disable some  */		case 'd':
X				case 'D':
X					switch (*p) {
X
X					case 'b':
X					case 'B':
X						bolding = NO;
X						break;
X					case 'p':
X					case 'P':
X						paging = NO;
X						break;
X					default:
X						break;
X					}
X					break;
X
X/* garbage       */             default:
X                                        usage();
X                                }
X                        }
X                        else
X			         lastpg = atoi(p);
X                }
X                else if (*p == '+') {
X                        p++;
X                        if ((frstpg = atoi(p)) == 0)
X                                usage();
X                }
X                else
X                        break;
X        }
X        if (i == argc)
X                usage();
X        if ((fp = fopen(argv[i], "r")) == NULL) {
X                fprintf(stderr, "%s: cannot open.\n",argv[i]);
X                exit(1);
X        }
X
X#ifdef DEBUG
X	fprintf(stderr,"OPened %s for Input Fp = %ld\n",argv[i],fp);
X#endif
X        if (p = argv[++i]) {
X                if ((outfile[0] = fopen(p, "w")) == NULL) {
X                        fprintf(stderr,"%s: cannot create.\n\n", p);
X                        exit(1);
X                }
X#ifdef DEBUG
X	fprintf(stderr,"OPened %s for Output\n",p);
X#endif
X
X	}
X	else
X	{
X		outfile[0] = stdout;
X#ifdef DEBUG
X	fprintf(stderr,"USing stdout for output\n");
X#endif
X	}
X
X			/* set output file level */
X	olevel = 0;
X	poutput = outfile[0];
X	/*
X	 * some minor initialisation
X	 */
X
X	for (i = 0; i < INSIZE; i++)
X		if (i % 8 == 0)
X			tabs[i] = YES;
X		else
X			tabs[i] = NO;
X
X	ehead[0] = '\n';
X	ehead[1] = EOS;
X	ohead[0] = '\n';
X	ohead[1] = EOS;
X	efoot[0] = '\n';
X	efoot[1] = EOS;
X	ofoot[0] = '\n';
X	ofoot[1] = EOS;
X
X			/* initialise contents linked list */
X
X	chead = (struct clist *) malloc(sizeof(struct clist));
X	clast = chead;
X	p_memoryus += sizeof(struct clist);
X
X        doroff(fp);
X        brk();
X        if (plval <= 100 && (lineno > 0 | outp > 0))
X                space(HUGE);
X        putchar('\n');
X
X	if(verbose) {
X		fprintf(stderr,"proff read in %6d textlines to produce\n",
X			p_txtlines);
X		fprintf(stderr,"              %6d lines\n",
X			p_outlines);
X		fprintf(stderr,"              %6d pages of formatted text.\n",
X			p_outpages);
X		fprintf(stderr,"\n%d bytes of memory was required\n",
X			p_memoryus);
X		fprintf(stderr,"for internal tables and lists.\n");
X	}
X#ifdef vms
X        exit(1);
X#else
X        exit(0);
X#endif
X}
!FaR!OuT!
echo x - proff.h
sed -e 's/^X//' > proff.h << '!FaR!OuT!'
X
X
X#include "defs.h"
X#include "lookup.h"
X
X#ifndef GLOBALS
X#ifdef vms
X#define extern globalref
X#endif
X	/* next available char; init = 0 */
Xextern int bp;
X	/* pushed-back characters */
Xextern char buf[BUFSIZE];
X	/* stack of file descriptors */
Xextern FILE *infile[NFILES];
X	/* current file is infile[level] */
Xextern int level;
X	/* stack of output file descriptors */
Xextern FILE *outfile[NFILES];
X	/* current output file is outfile[olevel] */
Xextern int olevel;
X	/* current output file pointer */
Xextern FILE *poutput;
X	/* system registers a..z */
Xextern int nr[26];
X	/* last char position in outbuf; init = 0 */
Xextern int outp;
X	/* width of text currently in outbuf; init = 0 */
Xextern int outw;
X	/* number of words in outbuf; init = 0 */
Xextern int outwds;
X	/* lines to be filled collect here */
Xextern char outbuf[MAXOUT];
X                       /* word in outbuf; init=0 */
X	/* current output page number; init = 0 */
Xextern int curpag;
X	/* next output page number; init = 1 */
Xextern int newpag;
X	/* next line to be printed; init = 0 */
Xextern int lineno;
X	/* page length in lines; init = PAGELEN = 66 */
Xextern int plval;
X	/* page length save area */
Xextern int savpl;
X	/* margin before and including header */
Xextern int m1val;
X	/* margin after header */
Xextern int m2val;
X	/* margin after last text line */
Xextern int m3val;
X	/* bottom margin, including footer */
Xextern int m4val;
X	/* last live line on page, = plval-m3val-m4val */
Xextern int bottom;
X	/* top of page title for even pages;init=NEWLINE */
Xextern char ehead[MAXLINE];
X	/* top of page title for odd  pages;init=NEWLINE */
Xextern char ohead[MAXLINE];
X	/* left,right margins for even header;init=inval,rmval */
Xextern int ehlim[2];
X	/* left,right margins for odd  header;init=inval,rmval */
Xextern int ohlim[2];
X	/* bot of page title for even pages;init=NEWLINE */
Xextern char efoot[MAXLINE];
X	/* bot of page title for odd  pages;init=NEWLINE */
Xextern char ofoot[MAXLINE];
X	/* left,right margins for even footer;init=inval,rmval */
Xextern int eflim[2];
X	/* left,right margins for odd  footer;init=inval,rmval */
Xextern int oflim[2];
X	/* flag for pausing between pages */
Xextern int stopx;
X	/* first page to begin printing with */
Xextern int frstpg;
X	/* last page to be printed */
Xextern int lastpg;
X	/* flag to indicate whether page should be printed */
Xextern int print;
X	/* number of blanks to offset page by; init = 0 */
Xextern int  offset;
X	/* verbose option; init = FALSE */
Xextern int verbose;
X	/* bolding option; init = YES; */
Xextern char bolding;
X	/* fill if YES; init = YES */
Xextern int fill;
X	/* current line spacing; init = 1 */
Xextern int lsval;
X	/* current indent; >= 0; init = 0 */
Xextern int inval;
X	/* current right margin; init = PAGEWIDTH = 60 */
Xextern int rmval;
X	/* current temporary indent; init = 0 */
Xextern int tival;
X	/* number of lines to center; init = 0 */
Xextern int ceval;
X	/* flag for continuous center */
Xextern char CEon;
X	/* number of lines to underline; init = 0 */
Xextern int ulval;
X	/* flag for continuous underline */
Xextern char ULon;
X	/* number of lines to boldface; init = 0 */
Xextern int boval;
X	/* flag for continuous bolding */
Xextern char BDon;
X	/* justification types for heads and foots; */
Xextern int tjust[3];          /* init = LEFT, CENTER, RIGHT */
X	/* number of lines to blank suppress; init=0 */
Xextern int bsval;
X	/* right justify filled lines if YES; init=YES */
Xextern int rjust;
X	/* tab stops; init every 8 spaces */
Xextern int tabs[INSIZE];
X	/* line control character; init = PERIOD */
Xextern char cchar;
X	/* universal escape - init = UNDERBAR */
Xextern char genesc;
X	/* character used to underline a BLANK; init = BLANK */
Xextern char ulblnk;
X	/* scratch arrays for use by various routines */
Xextern char tbuf1[MAXLINE];
Xextern char tbuf2[MAXLINE];
Xextern char tbuf3[MAXLINE];
Xextern char ttl[MAXLINE];
X	/* flag to process runoff symbols only */
Xextern char onlyrunoff;
X	/* flag to turn paging off */
Xextern char paging;
X	/* page number in roman numerals. Init = NO */
Xextern char roman;
X	/* autopar flag. Init = NO */
Xextern char autopar;
X	/* temporary indent value for autopar */
Xextern int autoprv;
X	/* hash tables for macros and variables */
Xextern struct hashlist *macrotab[HASHMAX];
Xextern struct hashlist *gentab[HASHMAX];
X	/* linked list entries for contents	*/
Xextern struct clist *chead;
Xextern struct clist *clast;
X	/* keep track of the work - VERBOSE opt.*/
X
Xextern int p_txtlines;
Xextern int p_outlines;
Xextern int p_outpages;
Xextern int p_memoryus;
X
X#ifdef vms
X#undef extern
X#endif
X
X#endif
X
X 	/* Why the hell can't people decare the routines they use */
X
X#ifndef INLOOK
Xextern int hash();
Xextern struct hashlist *lookup();
Xextern struct hashlist *install();
Xextern char *strsave();
Xextern struct lexlist *lexinstal();
Xextern struct lexlist *lexlook();
Xextern struct lexlist *remove();
X#endif
X
Xextern char *strcpy(), *strcat(), *malloc();
Xextern unsigned int strlen();
Xextern FILE *fopen(), *fclose();
!FaR!OuT!
echo x - proff01.c
sed -e 's/^X//' > proff01.c << '!FaR!OuT!'
X#include <stdio.h>
X#include <ctype.h>
X#include "proff.h"
X#include "debug.h"
X
X#define brk brrk
X
X/*
X * bold - bold face or overstrike a line
X *
X */
Xbold(buf,tbuf,size)
Xchar buf[];
Xchar tbuf[];
Xint  size;
X{
X	int  i,j;
X	dprintf("bold  ");
X
X	j = 0;
X	for (i = 0; buf[i] != '\n' && j < size - 2; i++) {
X		tbuf[j] = buf[i];
X		j++;
X		if (buf[i] != ' ' && buf[i] != '\t' &&
X		    buf[i] != BACKSPACE ) {
X			tbuf[j] = BACKSPACE;
X			tbuf[j+1] = tbuf[j-1];
X			j += 2;
X		}
X	}
X	tbuf[j] = '\n';
X	tbuf[j+1] = '\0';
X	strcpy(buf,tbuf);
X}
X
X/*
X * brk - end current filled line
X *
X */
Xbrk()
X{
X	dprintf("brk  ");
X	if (outp > 0) {
X		outbuf[outp] = '\n';
X		outbuf[outp+1] = EOS;
X		put(outbuf);
X	}
X	outp = 0;
X	outw = 0;
X	outwds = 0;
X}
X
X/*
X * center - center a line by setting tival
X *
X */
Xcenter(buf)
Xchar buf[];
X{
X	int	i;
X
X	dprintf("center  ");
X
X	i = (rmval + tival - width(buf)) / 2;
X	tival = (i > 0) ? i : 0;
X}
X
X/*
X * doroff - format text in file fp
X *
X */
Xdoroff(fp)
XFILE *fp;
X{
X	char inbuf[INSIZE];
X
X	infile[0] = fp;
X	for (level = 0; level > -1; level--) {
X
X#ifdef DEBUG
Xprintf("doroff: level %d FileP %ld\n",level, infile[level]);
X#endif
X
X		while (ngetln(inbuf, infile[level]) != EOF) {
X			if (inbuf[0] == cchar)	/* a command */
X				command(inbuf);
X			else {
X#ifdef rainbow
X				if (biosb(2))
X					exit(0);
X#endif
X				text(inbuf);
X				p_txtlines++;
X			}
X		}
X#ifdef DEBUG
Xprintf("doroff: Got EOF level %d FileP %ld\n",level, infile[level]);
X#endif
X
X		if (level > 0 && infile[level] > 0) {
X			fclose(infile[level]);
X			if (verbose)
X				fprintf(stderr,"       done.\n");
X		}
X	}
X}
X
X/*
X * gettl - copy title from buf to ttl
X *
X * modifies lim
X */
Xgettl(buf,ttl,lim)
Xchar *buf;
Xchar *ttl;
Xint lim[];
X{
X	while (!isspace(*buf))
X		buf++;
X	while (isspace(*buf))
X		buf++;
X	strcpy(ttl,buf);
X	lim[0] = inval;
X	lim[1] = rmval;
X}
X
X/*
X * getwrb - get a word INCLUDING the trailing blanks
X *
X */
Xint
Xgetwrb(in,i,out)
Xchar in[];
Xchar out[];
Xint *i;
X{
X	int j,k;
X	dprintf("getval  ");
X	k = *i;
X	j = 0;
X	while (in[k] != EOS && in[k] != ' ' &&
X	    in[k] != '\t' && in[k] != '\n') {
X		out[j] = in[k];
X		k++;
X		j++;
X	}
X	while (in[k] == ' ') {
X		out[j] = ' ';
X		k++;
X		j++;
X	}
X	*i = k;
X	out[j] = EOS;
X	return(j);
X}
X
X
X/*
X * gfield - get next tab or title field
X *
X */
Xint
Xgfield(buf, i, n, temp, delim)
Xchar buf[];
Xint *i;
Xint n;
Xchar temp[];
Xchar delim;
X{
X	int j,k;
X
X	dprintf("gfield  ");
X	j = 0;
X	k = *i;
X	if (n > 0) {
X		if (buf[k] == delim)
X			k++;
X		while (buf[k] != delim && buf[k] != EOS && buf[k] != '\n' &&
X		    j <= n) {
X			temp[j] = buf[k];
X			j++;
X			k++;
X		}
X	}
X	temp[j] = EOS;
X	while (buf[k] != delim && buf[k] != EOS && buf[k] != '\n')
X		k++;
X	*i = k;
X	return(j);
X}
X
X/*
X * jcopy - scopy without copying EOS
X *
X */
Xjcopy(from, i, to, j)
Xchar from[];
Xchar to[];
Xint i;
Xint j;
X{
X	int k1, k2;
X	dprintf("jcopy  ");
X
X	k1 = i;
X	k2 = j;
X	while (from[k1] != EOS) {
X		to[k2] = from[k1];
X		k1++;
X		k2++;
X	}
X}
X
X/*
X * justfy - justifies string in its tab column
X * */
Xjustfy(in, left, right, type, out)
Xchar in[];
Xchar out[];
Xint left;
Xint right;
Xint type;
X{
X	int j,k, n;
X
X	dprintf("justfy  ");
X	n = width(in);
X	if (type == RIGHT)
X		jcopy(in, 0, out, right-n);
X	else if (type == CENTER) {
X		k = (right+left-n) / 2;
X		j = (k > left) ? k : left;
X		jcopy(in, 0, out, j);
X	}
X	else 
X	    jcopy(in, 0, out, left);
X}
X
X/*
X * leadbl - delete leading blanks, set tival
X *
X */
Xleadbl(buf)
Xchar buf[];
X{
X	int i, j;
X
X	dprintf("leadbl  ");
X	brk();
X	for (i = 0; buf[i] == ' '; i++)     /* find 1st non-blank */
X		;
X	if (buf[i] != '\n')
X		if (autopar) {
X			put("\n");	/* blank line */
X			tival = inval + autoprv;
X		}
X		else
X			tival = inval + i;	    /* ??????????? */
X	for (j = 0; buf[i] != EOS; j++) {   /* move line to left */
X		buf[j] = buf[i];
X		i++;
X	}
X	buf[j] = EOS;
X}
X
X/*
X * ngetln - get next line from f into line
X *
X */
Xint
Xngetln(line, f)
Xchar line[];
XFILE *f;
X{
X	int c, i;
X
X#ifdef DEBUG
X	printf("ngetln+++: bp %d\n",bp);
X#endif
X
X	for (i = 0; (c = (bp >= 0) ? buf[bp--] : getc(f)) != EOF; ) {
X		if (i < MAXLINE - 1) {
X			line[i++] = (char) c;
X#ifdef DEBUG
X	printf("ngetln++: i %d c %c %d\n",i,c,c);
X#endif
X		}
X		if (c == '\n' || c == '\r')
X			break;
X	}
X	line[i] = EOS;
X	if (i == 0 && c == EOF)
X		i = EOF;
X#ifdef DEBUG
X	printf("ngetln: %s (%d, %d) (line)\n",line,strlen(line),i);
X#endif
X	return(i);
X}
X
X/*
X * pbstr - push string back onto input
X *
X */
Xpbstr(in)
Xchar in[];
X{
X
X	int i;
X
X	dprintf("pbstr  ");
X	for (i = strlen(in) - 1; i >= 0; i--)
X		putbak(in[i]);
X}
X
X/*
X * pfoot - put out page footer
X *
X */
Xpfoot()
X{
X
X	dprintf("pfoot  ");
X	skipl(m3val);
X	if (m4val > 0) {
X		if (curpag % 2 == 1)
X			puttl(efoot, eflim, curpag);
X		else
X			puttl(ofoot, oflim, curpag);
X	}
X	if (print == YES)		/* flush the page */
X	{
X		putchar(PAGEJECT);	/* ...		  */
X		p_outpages++;
X		if (stopx > 0)		/* -s, so flush ^L*/
X			putchar('\n');
X	}
X}
X
X/*
X * phead - put out page header
X *
X */
Xphead()
X{
X	dprintf("phead  ");
X
X	curpag = newpag;
X	if (curpag >= frstpg && curpag <= lastpg)
X		print = YES;
X	else 
X	    print = NO;
X	if(stopx > 0 && print == YES)
X		prmpt(&stopx);
X	newpag++;
X	if (m1val > 0) {
X		skipl(m1val-1);
X		if (curpag % 2 == 0)
X			puttl(ehead, ehlim, curpag);
X		else
X			puttl(ohead, ohlim, curpag);
X	}
X	skipl(m2val);
X	lineno = m1val + m2val + 1;
X}
X
X/*
X * prmpt - pause for paper insertion
X * prompt if i == 1; increment i
X *
X */
Xprmpt(i)
Xint *i;
X{
X	int junk,j;
X	static char bellst[2] = { BEL, EOS};
X
X	dprintf("prmpt  ");
X	j = *i;
X	if (j == 1)
X#ifdef rainbow
X		printf("%s\033[7minsert paper and type return\033[0m ",bellst);
X#else
X		printf("%sinsert paper and type return ",bellst);
X#endif
X	else
X		printf(bellst);
X	junk = getchar();
X	*i = ++j;
X}
X
X/*
X * Put - put out line with proper spacing and indenting
X *
X */
Xput(buf)
Xchar buf[];
X{
X	register int i;
X	dprintf("put  ");
X	if (lineno == 0 || lineno > bottom)
X		phead();
X
X	if ( print == YES ) {
X		if (buf[0] == '\n') {	/* empty line.. */
X			putchar('\n');
X			p_outlines++;
X		}
X		else {
X			for ( i = 1 ; i <= offset ; i++ ) /* page offset */
X				putchar(' ');
X			for ( i = 1 ; i <= tival ; i++ )  /* indenting   */
X				putchar(' ');
X
X			while (*buf != '\0') {
X				putchar(*buf);
X				buf++;
X			}
X			p_outlines++;
X		}
X	}
X
X	tival = inval;
X	skipl(((lsval-1 < bottom-lineno) ? lsval-1 : bottom-lineno));
X	lineno += lsval;
X
X	if (lineno > bottom)
X		pfoot();
X
X}
X
X/*
X * putbak - push character back onto input
X *
X */
Xputbak(c)
Xchar c;
X{
X	dprintf("putbak  ");
X
X	bp++;
X	if (bp > BUFSIZE)
X		error("too many characters pushed back.\n");
X	buf[bp] = c;
X}
X
X
X/*
X * puttl - put out title line with optional page number & date
X * 
X */
Xputtl(buf, lim, pageno)
Xchar buf[];
Xint lim[];
Xint pageno;
X{
X	char chars[9],cdate[27];
X	char rmstr[MAXTOK];
X	char delim;
X	char *tp;
X	int j;
X	int nc, n, i, left, right, ncd;
X
X	dprintf("puttl  ");
X	if (print == NO)
X		return;
X	left = lim[0];	/* no more +1 here */
X	right = lim[1]; /* no more +1 here */
X	nc = itoc(pageno, chars, MAXCHARS);
X	if (roman) {
X		nc = cvtroman(chars,rmstr);
X		strcpy(chars,rmstr);
X	}
X	getnow(cdate);
X	ncd = strlen(cdate);
X	i = 0;
X	delim = buf[i];
X	for (j = 0; j < right; j++)
X		ttl[j] = ' ';
X	n = 0;
X	do {
X		if (gfield(buf, &i, right-left, tbuf1, delim) > 0) {
X			subst(tbuf1, PAGENUM, tbuf2, chars, nc);
X			subst(tbuf2, CURRENTDATE, tbuf1, cdate, ncd);
X			justfy(tbuf1, left, right, tjust[n], ttl);
X		}
X		n++;		/* update title counter */
X	} 
X	while (buf[i] != EOS && buf[i] != '\n' && n != 3);
X
X	for( ; right >= 1 ; right--)
X		if( ttl[right-1] != ' ' )
X			break;
X	ttl[right] = '\n';
X	ttl[right+1] = EOS;
X	for (i = 1; i <= offset; i++)
X		putchar(' ');  			/* offset */
X	tp = ttl;
X	while (*tp != '\0') {
X		putchar(*tp);
X		tp++;
X	}
X	p_outlines++;
X}
X
X/*
X * set - set parameter and check range
X *
X */
Xset(param, val, argtyp, defval, minval, maxval)
Xint *param;
Xint val;
Xint argtyp;
Xint defval;
Xint minval;
Xint maxval;
X{
X	int i;
X	dprintf("set  ");
X	i = *param;
X	if (argtyp == '\n')      		/* defaulted */
X		i = defval;
X	else if (argtyp == '+')		      	/* relative +*/
X		i += val;
X	else if (argtyp == '-')   		/* relative -*/
X		i -= val;
X	else               			/* absolute  */
X	i = val;
X	i = (i < maxval) ? i : maxval; 		/* min 	     */
X	i = (i > minval) ? i : minval; 		/* max 	     */
X	*param = i;
X}
X
X/*
X* skipl - output  n  blank lines
X*
X*/
Xskipl(n)
Xregister int n;
X{
X	register int i;
X
X	dprintf("skip  ");
X	if (print == YES)
X		for (i = 1; i <= n; i++) {
X			putchar('\n');
X			p_outlines++;
X		}
X}
X
X/*
X * space - space  n  lines or to bottom of page
X *
X */
Xspace(n)
Xint n;
X{
X
X	dprintf("space  ");
X	brk();
X	if (lineno > bottom)
X		return;
X	if (lineno == 0)
X		phead();
X	skipl(((n < bottom+1-lineno) ? n : bottom+1-lineno));
X	lineno += n;
X	if (lineno > bottom)
X		pfoot();
X}
X
X/*
X * spread - spread words to justify right margin
X *
X */
Xspread(buf, outp, nextra, outwds)
Xchar buf[];
Xint outp;
Xint nextra;
Xint outwds;
X{
X	int dir = 0;
X
X	register int i, j;
X	int nb, ne, nholes;
X
X	dprintf("spread  ");
X	if (nextra <= 0 || outwds <= 1)
X		return;
X	dir = 1 - dir;   /* reverse previous direction */
X	ne = nextra;
X	nholes = outwds - 1;
X	if (tival != inval && nholes > 1)
X		nholes--;
X	i = outp - 1;
X	j = (MAXOUT-2 < i+ne) ? MAXOUT-2 : i+ne; /* leave room for '\n', EOS */
X	while (i < j) {
X		buf[j] = buf[i];
X		if (buf[i] == ' ' && buf[i-1] != ' ') {
X			if (dir == 0)
X				nb = (ne-1) / nholes + 1;
X			else
X				nb = ne / nholes;
X			ne -= nb;
X			nholes--;
X			for ( ; nb > 0; nb--) {
X				j--;
X				buf[j] = ' ';
X			}
X		}
X		i--;
X		j--;
X	}
X}
X
X/*
X * subst - substitutes a string for a specified character
X *
X */
Xsubst(in, chr, out, subara, n)
Xchar in[];
Xchar chr;
Xchar out[];
Xchar subara[];
Xint n;
X{
X	register int i, j, k;
X
X	dprintf("subst  ");
X	j = 0;
X	for (i = 0; in[i] != EOS; i++)
X		if (in[i] == chr)
X			for (k = 0; k < n; k++) {
X				out[j] = subara[k];
X				j++;
X			}
X		else {
X			out[j] = in[i];
X			j++;
X		}
X	out[j] = EOS;
X}
X
X/*
X * Text	process text lines
X *
X */
X
Xtext(inbuf)
Xchar inbuf[];
X{
X	int	i;
X	register int j;
X	char	wrdbuf[INSIZE];
X
X	dovar(wrdbuf,inbuf);		/*  expand variables */
X	strcpy(inbuf,wrdbuf);
X	doesc(inbuf, wrdbuf, INSIZE);	/*  expand escapes   */
X	dotabs(inbuf, wrdbuf, INSIZE);  /*  expand tabs      */
X
X	if(inbuf[0] == ' ' || inbuf[0] == '\n')
X		leadbl(inbuf); 		/* move left, set tival */
X	if(ulval > 0 || ULon) 		/* word underlining */
X	{
X		underl(inbuf, wrdbuf, INSIZE);
X		ulval--;
X	}
X	if(boval > 0 || BDon) 		/* boldfacing */
X	{
X		bold( inbuf, wrdbuf, INSIZE);
X		boval--;
X	}
X	if(ceval > 0 || CEon) 		/* centering */
X	{
X		center(inbuf);
X		put(inbuf);
X		ceval--;
X	}
X	else if( inbuf[0] == '\n' ) 	/* all blank line */
X		put(inbuf);
X	else if( fill == NO ) 		/* unfilled text */
X		put(inbuf);
X	else 				/* filled text */
X	{
X		i = strlen(inbuf) - 1;
X		inbuf[i] = ' ';
X		if( inbuf[i-1] == '.' )
X		{
X			i++;
X			inbuf[i] = ' ';
X		}
X		inbuf[i+1] = EOS;
X		for( i = 0 ; getwrb(inbuf, &i, wrdbuf) > 0 ; )
X			putwrd(wrdbuf);
X	}
X}
X
X/*
X * Underl	underline words in a line
X *
X */
Xunderl(buf, tbuf, size)
Xchar buf[];
Xchar tbuf[];
Xint size;
X{
X	int i, j;
X
X	j = 0;
X	for(i = 0 ; buf[i] != '\n' && j < size - 2; i++) {
X		if( buf[i] != ' ' && buf[i] != BACKSPACE && buf[i] != '_' ) {
X			tbuf[j++] = '_';
X			tbuf[j++] = BACKSPACE;
X		}
X		if( buf[i] == BLANK )
X			tbuf[j++] = ulblnk;
X		else
X			tbuf[j++] = buf[i];
X	}
X
X	tbuf[j] = '\n';
X	tbuf[j+1] = '\0';
X	strcpy(buf, tbuf);
X}
X
X/*
X * width - compute width of character string
X *
X */
Xint
Xwidth(buf)
Xchar buf[];
X{
X	int k,i;
X
X	dprintf("width  ");
X	k = 0;
X	for (i = 0; buf[i] != EOS; i++)
X		if (buf[i] == BACKSPACE)
X			k--;
X		else if (buf[i] >= ' ' && buf[i] <= '~')
X			k++;
X	return(k);
X}
X/*
X * getnow - get the date from command line if present.
X *          if not specified, prompt user for it.
X *
X * (stub)
X */
Xgetnow(date)
Xchar date[];
X{
X	dprintf("getnow  ");
X	strcpy(date,"00-xxx-1900 00:00:00");
X}
!FaR!OuT!
echo x - proff02.c
sed -e 's/^X//' > proff02.c << '!FaR!OuT!'
X#include <stdio.h>
X#include <ctype.h>
X#include "defs.h"
X#include "debug.h"
X
X/*
X * addset - put c in array[i], if it fits, increment i
X *
X */
Xint
Xaddset(c,array,i,maxsize)
Xchar c;
Xchar array[];
Xint *i;
Xint maxsize;
X{
X	int n,status = NO;
X	dprintf("addset  ");
X	n = *i;
X	if (n <= maxsize - 1) {
X		array[n++] = c;
X		status = YES;
X	}
X	*i = n;
X	return(status);
X}
X
X/*
X * addstr - add string s to str[i] if it fits, increment i
X *
X */
Xint
Xaddstr(s,str,i,maxsize)
Xchar s[];
Xchar str[];
Xint *i;
Xint maxsize;
X{
X	int k,j,status = NO;
X
X	dprintf("addstr  ");
X	j = *i;
X	if (j + strlen(s) <= maxsize - 1) {
X		for (k = 0; s[k] != EOS; k++)
X			str[j++] = s[k];
X		status = YES;
X	}
X	*i = j;
X	return(status);
X}
X
X/*
X * ctoi - convert string at in[i] to integer, increment i
X *
X */
Xint
Xctoi(in,i)
Xchar in[];
Xint *i;
X{
X	int j,n,sign;
X
X	dprintf("ctoi  ");
X	n = 0;
X	for (j = *i; in[j] == ' ' || in[j] == '\t'; j++)
X		;         /* skip leading garbage */
X	sign = 1;
X	if (in[j] == '+' || in[j] == '-') /* sign */
X		sign = (in[j++] == '+') ? 1 : -1;
X	for (n = 0; in[j] >= '0' && in[j] <= '9'; j++)
X		n = 10 * n + in[j] - '0';
X	*i = j;
X	return(sign * n);
X}
X
X/*
X * error - print message and terminate
X *
X */
Xerror(s)
Xchar s[];
X{
X	fprintf(stderr,"%s\n",s);
X	exit(1);
X}
X
X/*
X * getwrd - get non-blank word from in[i] into out, increment i
X *
X */
Xint
Xgetwrd(in,i,out)
Xchar in[];
Xint *i;
Xchar out[];
X{
X	int j,size = 0;
X
X	for (j = *i; in[j] == '\t' || in[j] == ' '; j++)
X		;         /* skip leading garbage */
X	while (in[j] != ' ' && in[j] != '\t' && 
X	    in[j] != EOS && in[j] != '\n')
X		out[size++] = in[j++];
X	out[size++] = EOS;
X	*i = j;
X#ifdef DEBUG
X	printf("getwrd: %s\n",out);
X#endif
X	return(size);
X}
X/*
X * skipbl - skip blanks, tabs at str[i], increment i
X *
X */
Xskipbl(str,i)
Xchar str[];
Xint *i;
X{
X	int n;
X	dprintf("skipbl  ");
X	n = *i;
X	while (str[n] == ' ' || str[n] == '\t')
X		n++;
X	*i = n;
X}
X
X/*
X * itoc - special version of itoa
X *
X */
Xint
Xitoc(n,str,size)
Xint n;
Xchar str[];
Xint size;
X{
X
X	int i,j,k,sign;
X	char c;
X
X	dprintf("itoc  ");
X	if ((sign = n) < 0)
X		n = -n;
X	i = 0;
X	do {
X		str[i++] = n % 10 + '0'; 
X	} 
X	while ((n /= 10) > 0 && i < size-2);
X	if (sign < 0 && i < size-1)
X		str[i++] = '-';
X	str[i] = EOS;
X	/*
X		 * reverse the string and plug it back in
X		 *
X */
X	for (j = 0, k = strlen(str) - 1; j < k; j++, k--) {
X		c = str[j];
X		str[j] = str[k];
X		str[k] = c;
X	}
X	return(i);
X}
X
X/*
X * usage - obvious..
X *
X */
Xusage()
X{
X#ifdef rainbow
X	fprintf(stderr,"%s %s",
X	"usage: proff \033[7m[+n] [-n] [-v] [-ifile] [-s] [-pon]\033[0m",
X	"\033[1minfile\033[0m \033[7m[outfile]\033[0m\n");
X#else
X	fprintf(stderr,
X	"usage: proff [+n] [-n] [-v] [-ifile] [-s] [-pon] infile [outfile]\n");
X#endif
X	exit(0);
X}
!FaR!OuT!
exit
-- 
 __________ ______ ____ _____ ___
/_________//___   ||__|/____|/__/   Richard E. Sansom
   ___    ____/  / ____________     TRW Electronics & Defense Sector
  /  /   /  /\  <  |    /|    /     One Space Park Drive, R3/1028
 /  /   /  /  \  \ |   / |   /      Redondo Beach, CA 90278
/__/   /__/    \__\|__/  |__/       {...decvax,ucbvax,ihnp4}!trwrb!sansom