V9/cmd/troff/tc.c
/*
* drive 4014 scope
*/
/*
output language from troff:
all numbers are character strings
sn size in points
fn font as number from 1-n
cx ascii character x
Cxyz funny char xyz. terminated by white space
Hn go to absolute horizontal position n
Vn go to absolute vertical position n (down is positive)
hn go n units horizontally (relative)
vn ditto vertically
nnc move right nn, then print c (exactly 2 digits!)
(this wart is an optimization that shrinks output file size
about 35% and run-time about 15% while preserving ascii-ness)
Dt ...\n draw operation 't':
Dl x y line from here by x,y
Dc d circle of diameter d with left side here
De x y ellipse of axes x,y with left side here
Da x y r arc counter-clockwise by x,y of radius r
D~ x y x y ... wiggly line by x,y then x,y ...
nb a end of line (information only -- no action needed)
b = space before line, a = after
p new page begins -- set v to 0
#...\n comment
x ...\n device control functions:
x i init
x T s name of device is s
x r n h v resolution is n/inch
h = min horizontal motion, v = min vert
x p pause (can restart)
x s stop -- done for ever
x t generate trailer
x f n s font position n contains font s
x H n set character height to n
x S n set slant to N
Subcommands like "i" are often spelled out like "init".
*/
#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include "dev.h"
#define NFONT 10
int output = 0; /* do we do output at all? */
int nolist = 0; /* output page list if > 0 */
int olist[20]; /* pairs of page numbers */
int erase = 1;
float aspect = 1.5; /* default aspect ratio */
int (*sigint)();
int (*sigquit)();
struct dev dev;
struct font *fontbase[NFONT];
short psizes[] ={ 11, 16, 22, 36, 0}; /* approx sizes available */
short *pstab = psizes;
int nsizes = 4;
int pscode[] ={ ';', ':', '9', '8'};
int nfonts;
int smnt; /* index of first special font */
int nchtab;
char *chname;
short *chtab;
char *fitab[NFONT];
char *widthtab[NFONT]; /* widtab would be a better name */
char *codetab[NFONT]; /* device codes */
#define FATAL 1
#define BMASK 0377
int keepon = 0;
int dbg = 0;
long lineno = 0;
int res = 972; /* input assumed computed according to this resolution */
/* initial value to avoid 0 divide */
FILE *tf = stdout; /* output file */
char *fontdir = "/usr/lib/font";
extern char devname[];
FILE *fp = stdin; /* input file pointer */
main(argc, argv)
char *argv[];
{
char buf[BUFSIZ];
float atof();
int done();
setbuf(stdout, buf);
while (argc > 1 && argv[1][0] == '-') {
switch (argv[1][1]) {
case 'T':
if (strcmp(&argv[1][2], "cat") == 0) { /* use the old one */
if (fork() == 0) {
execv("/usr/bin/oldtc", argv);
fprintf(stderr, "tc: can't find oldtc\n");
}
wait();
exit(1);
}
break;
case 'a':
aspect = atof(&argv[1][2]);
break;
case 'e':
erase = 0;
break;
case 'o':
outlist(&argv[1][2]);
break;
case 'd':
dbg = atoi(&argv[1][2]);
if (dbg == 0) dbg = 1;
break;
case 'c':
keepon = 1;
break;
}
argc--;
argv++;
}
sigint = signal(SIGINT, done);
sigquit = signal(SIGQUIT, SIG_IGN);
if (argc <= 1)
conv(stdin);
else
while (--argc > 0) {
if (strcmp(*++argv, "-") == 0)
fp = stdin;
else if ((fp = fopen(*argv, "r")) == NULL)
error(FATAL, "can't open %s", *argv);
conv(fp);
fclose(fp);
}
done();
}
outlist(s) /* process list of page numbers to be printed */
char *s;
{
int n1, n2, i;
nolist = 0;
while (*s) {
n1 = 0;
if (isdigit(*s))
do
n1 = 10 * n1 + *s++ - '0';
while (isdigit(*s));
else
n1 = -9999;
n2 = n1;
if (*s == '-') {
s++;
n2 = 0;
if (isdigit(*s))
do
n2 = 10 * n2 + *s++ - '0';
while (isdigit(*s));
else
n2 = 9999;
}
olist[nolist++] = n1;
olist[nolist++] = n2;
if (*s != '\0')
s++;
}
olist[nolist] = 0;
if (dbg)
for (i=0; i<nolist; i += 2)
printf("%3d %3d\n", olist[i], olist[i+1]);
}
in_olist(n) /* is n in olist? */
int n;
{
int i;
if (nolist == 0)
return(1); /* everything is included */
for (i = 0; i < nolist; i += 2)
if (n >= olist[i] && n <= olist[i+1])
return(1);
return(0);
}
conv(fp)
register FILE *fp;
{
register int c, k;
int m, n, i, n1, m1;
char str[100], buf[300];
while ((c = getc(fp)) != EOF) {
switch (c) {
case '\n': /* when input is text */
lineno++;
case ' ':
case 0: /* occasional noise creeps in */
break;
case '{': /* push down current environment */
t_push();
break;
case '}':
t_pop();
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* two motion digits plus a character */
hmot((c-'0')*10 + getc(fp)-'0');
put1(getc(fp));
break;
case 'c': /* single ascii character */
put1(getc(fp));
break;
case 'C':
fscanf(fp, "%s", str);
put1s(str);
break;
case 't': /* straight text */
fgets(buf, sizeof(buf), fp);
lineno++;
t_text(buf);
break;
case 'D': /* draw function */
fgets(buf, sizeof(buf), fp);
lineno++;
switch (buf[0]) {
case 'l': /* draw a line */
sscanf(buf+1, "%d %d", &n, &m);
drawline(n, m, ".");
break;
case 'c': /* circle */
sscanf(buf+1, "%d", &n);
drawcirc(n);
break;
case 'e': /* ellipse */
sscanf(buf+1, "%d %d", &m, &n);
drawellip(m, n);
break;
case 'a': /* arc */
sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
drawarc(n, m, n1, m1);
break;
case '~': /* wiggly line */
drawwig(buf+1);
break;
default:
error(FATAL, "unknown drawing function %s\n", buf);
break;
}
break;
case 's':
fscanf(fp, "%d", &n); /* ignore fractional sizes */
setsize(t_size(n));
break;
case 'f':
fscanf(fp, "%s", str);
setfont(t_font(str));
break;
case 'H': /* absolute horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hgoto(k);
break;
case 'h': /* relative horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hmot(k);
break;
case 'w': /* word space */
break;
case 'V':
fscanf(fp, "%d", &n);
vgoto(n);
break;
case 'v':
fscanf(fp, "%d", &n);
vmot(n);
break;
case 'p': /* new page */
fscanf(fp, "%d", &n);
t_page(n);
break;
case 'n': /* end of line */
while (getc(fp) != '\n')
;
t_newline();
break;
case '#': /* comment */
while (getc(fp) != '\n')
;
lineno++;
break;
case 'x': /* device control */
devcntrl(fp);
lineno++;
break;
default:
error(!FATAL, "unknown input character %o %c\n", c, c);
while (getc(fp) != '\n')
;
}
}
}
devcntrl(fp) /* interpret device control functions */
FILE *fp;
{
char str[20];
int c, n;
fscanf(fp, "%s", str);
switch (str[0]) { /* crude for now */
case 'i': /* initialize */
fileinit();
t_init(0);
break;
case 'T': /* device name */
fscanf(fp, "%s", devname);
break;
case 't': /* trailer */
t_trailer();
break;
case 'p': /* pause -- can restart */
t_reset('p');
break;
case 's': /* stop */
t_reset('s');
break;
case 'r': /* resolution assumed when prepared */
fscanf(fp, "%d", &res);
break;
case 'f': /* font used */
fscanf(fp, "%d %s", &n, str);
loadfont(n, str);
break;
}
while (getc(fp) != '\n') /* skip rest of input line */
;
}
fileinit() /* read in font and code files, etc. */
{
}
fontprint(i) /* debugging print of font i (0,...) */
{
}
loadcode(n, nw) /* load codetab on position n (0...); #chars is nw */
int n, nw;
{
}
loadfont(n, s) /* load font info for font s on position n (1...) */
int n;
char *s;
{
}
#define ESC 033
#define MAXY (3071-100)
#define US 037 /* text mode */
#define GS 035 /* graphics mode */
#define FF 014
error(f, s, a1, a2, a3, a4, a5, a6, a7) {
fprintf(stderr, "%c%c%c", US, ESC, ';'); /* reset terminal sensibly */
fprintf(stderr, "tc: ");
fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7);
fprintf(stderr, " near line %ld\n", lineno);
if (f)
done(2);
}
/*
Here beginneth all the stuff that really depends
on the 202 (we hope).
*/
char devname[20] = "4014";
#define oput(c) if (output) putchar(c); else;
int stopped = 0;
int ohx = -1;
int ohy = -1;
int oxb = -1;
int oly = -1;
int olx = -1;
int skip;
int size = 1;
int font = 1; /* current font */
int hpos; /* horizontal position where we are supposed to be next (left = 0) */
int vpos; /* current vertical position (down positive) */
int horig; /* h origin of current block; hpos rel to this */
int vorig; /* v origin of current block; vpos rel to this */
int DX = 10; /* step size in x for drawing */
int DY = 10; /* step size in y for drawing */
int drawdot = '.'; /* draw with this character */
int drawsize = 1; /* shrink by this factor when drawing */
t_init(reinit) /* initialize device */
int reinit;
{
fflush(stdout);
stopped = 0;
if (erase) {
oput(ESC);
oput(FF);
oput(US);
}
hpos = vpos = 0;
setsize(t_size(10)); /* start somewhere */
sendpt();
}
#define MAXSTATE 5
struct state {
int ssize;
int sfont;
int shpos;
int svpos;
int shorig;
int svorig;
};
struct state state[MAXSTATE];
struct state *statep = state;
t_push() /* begin a new block */
{
hflush();
statep->ssize = size;
statep->sfont = font;
statep->shorig = horig;
statep->svorig = vorig;
statep->shpos = hpos;
statep->svpos = vpos;
horig = hpos;
vorig = vpos;
hpos = vpos = 0;
if (statep++ >= state+MAXSTATE)
error(FATAL, "{ nested too deep");
hpos = vpos = 0;
}
t_pop() /* pop to previous state */
{
if (--statep < state)
error(FATAL, "extra }");
size = statep->ssize;
font = statep->sfont;
hpos = statep->shpos;
vpos = statep->svpos;
horig = statep->shorig;
vorig = statep->svorig;
}
int np; /* number of pages seen */
int npmax; /* high-water mark of np */
int pgnum[100]; /* their actual numbers */
long pgadr[100]; /* their seek addresses */
t_page(n) /* do whatever new page functions */
{
long ftell();
int c, m, i;
char buf[100], *bp;
pgnum[np++] = n;
pgadr[np] = ftell(fp);
if (np > npmax)
npmax = np;
if (output == 0) {
output = in_olist(n);
t_init(1);
return;
}
/* have just printed something, and seen p<n> for next one */
vgoto(11 * res - 100);
sendpt();
oput(US);
fflush(stdout);
if (keepon) {
t_init(1);
return;
}
next:
for (bp = buf; (*bp = readch()); )
if (*bp++ == '\n')
break;
*bp = 0;
switch (buf[0]) {
case 0:
done();
break;
case '\n':
if (stopped)
done();
output = in_olist(n);
t_init(1);
return;
case '!':
callunix(&buf[1]);
fputs("!\n", stderr);
break;
case 'e':
erase = 1 - erase;
break;
case 'a':
aspect = atof(&buf[1]);
break;
case '-':
case 'p':
m = atoi(&buf[1]) + 1;
if (fp == stdin) {
fputs("you can't; it's not a file\n", stderr);
break;
}
if (np - m <= 0) {
fputs("too far back\n", stderr);
break;
}
np -= m;
fseek(fp, pgadr[np], 0);
output = 1;
t_init(1);
return;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
m = atoi(&buf[0]);
for (i = 0; i < npmax; i++)
if (m == pgnum[i])
break;
if (i >= npmax || fp == stdin) {
fputs("you can't\n", stderr);
break;
}
np = i + 1;
fseek(fp, pgadr[np], 0);
output = 1;
t_init(1);
return;
case 'o':
outlist(&buf[1]);
output = 0;
t_init(1);
return;
case '?':
fputs("!cmd unix cmd\n", stderr);
fputs("p print this page again\n", stderr);
fputs("-n go back n pages\n", stderr);
fputs("n print page n (previously printed)\n", stderr);
fputs("o... set the -o output list to ...\n", stderr);
fputs("en n=0 -> don't erase; n=1 -> erase\n", stderr);
fputs("an sets aspect ratio to n\n", stderr);
break;
default:
fputs("?\n", stderr);
break;
}
goto next;
}
t_newline() /* do whatever for the end of a line */
{
hpos = 0;
}
t_size(n) /* convert integer to internal size number*/
int n;
{
int i;
if (n <= pstab[0])
return(1);
else if (n >= pstab[nsizes-1])
return(nsizes);
for (i = 0; n > pstab[i]; i++)
;
return(i+1);
}
t_font(s) /* convert string to internal font number */
char *s;
{
int n;
n = atoi(s);
if (n < 1 || n > nfonts)
n = 1;
return(n);
}
t_text(s) /* print string s as text */
char *s;
{
int c, w;
char str[100];
if (!output)
return;
w = res / 2 * pstab[size-1] / 72;
while ((c = *s++) != '\n') {
if (c == '\\') {
switch (c = *s++) {
case '\\':
case 'e':
put1('\\');
break;
case '(':
str[0] = *s++;
str[1] = *s++;
str[2] = '\0';
put1s(str);
break;
}
} else {
put1(c);
}
hmot(w);
}
}
t_reset(c)
{
int n;
output = 1;
fflush(stdout);
if (c == 's') {
stopped = 1;
t_page(9999);
}
}
t_trailer()
{
}
hgoto(n)
{
hpos = n; /* this is where we want to be */
/* before printing a character, */
/* have to make sure it's true */
}
hmot(n) /* generate n units of horizontal motion */
int n;
{
hgoto(hpos + n);
}
hflush() /* actual horizontal output occurs here */
{
if (output)
sendpt();
}
vgoto(n)
{
vpos = n;
}
vmot(n) /* generate n units of vertical motion */
int n;
{
vgoto(vpos + n); /* ignores rounding */
}
put1s(s) /* s is a funny char name */
char *s;
{
int i;
char *p;
extern char *spectab[];
static char prev[10] = "";
static int previ;
if (!output)
return;
if (strcmp(s, prev) != 0) {
previ = -1;
for (i = 0; spectab[i] != 0; i += 2)
if (strcmp(spectab[i], s) == 0) {
strcpy(prev, s);
previ = i;
break;
}
}
if (previ >= 0) {
hflush();
oput(US);
for (p = spectab[previ+1]; *p; p++)
oput(*p);
} else
prev[0] = 0;
}
put1(c) /* output char c */
int c;
{
if (!output)
return;
hflush();
oput(US);
oput(c);
}
setsize(n) /* set point size to n (internal) */
int n;
{
if (!output)
return;
if (n == size)
return; /* already there */
oput(ESC);
oput(pscode[n-1]);
size = n;
}
t_fp(n, s) /* font position n now contains font s */
int n;
char *s;
{
}
setfont(n) /* set font to n */
int n;
{
}
done()
{
output = 1;
hgoto(0);
vgoto(11 * res - 100); /* bottom of page */
sendpt();
oput(US);
oput(ESC);
oput(';');
oput(US);
fflush(stdout);
exit(0);
}
callunix(line)
char line[];
{
int rc, status, unixpid;
if( (unixpid=fork())==0 ) {
signal(SIGINT,sigint); signal(SIGQUIT,sigquit);
close(0); dup(2);
execl("/bin/sh", "-sh", "-c", line, 0);
exit(255);
}
else if(unixpid == -1)
return;
else{ signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN);
while( (rc = wait(&status)) != unixpid && rc != -1 ) ;
signal(SIGINT, done); signal(SIGQUIT,sigquit);
}
}
readch(){
char c;
if (read(2,&c,1)<1) c=0;
return(c);
}
sendpt(){
int hy,xb,ly,hx,lx;
int xx, yy;
float fx, fy;
fx = hpos + horig;
fy = vpos + vorig;
xx = (fx * MAXY / 11) / res * aspect + 0.5;
yy = MAXY - (fy * MAXY / 11) / res + 0.5;
oput(GS);
hy = ((yy>>7) & 037);
xb = ((xx & 03) + ((yy<<2) & 014) & 017);
ly = ((yy>>2) & 037);
hx = ((xx>>7) & 037);
lx = ((xx>>2) & 037);
if(hy != ohy)oput(hy | 040);
if(xb != oxb)oput(xb | 0140);
if((ly != oly) || (hx != ohx) || (xb != oxb))
oput(ly | 0140);
if(hx != ohx)oput(hx | 040);
oput(lx | 0100);
ohy = hy;
oxb = xb;
oly = ly;
ohx = hx;
olx = lx;
}
char *spectab[] ={
"em", "--",
"en", "-",
"hy", "-",
"ff", "ff",
"fi", "fi",
"fl", "fl",
"Fi", "ffi",
"Fl", "ffl",
"ct", "\033\016Z\bM\033\017", /*cent sign*/
"de", "\033\016J\033\017", /*degree*/
"dg", "\033\016M\b_\033\017", /*dagger*/
"rg", "\033\016O\b&\033\017", /*registered*/
"bu", "\033\016O\b~\033\017", /*bullet*/
"fm", "'",
"co", "\033\016O\b#\033\017", /*copyright*/
"sq", "\033\016L\033\017", /*square*/
"*q", "\033\016(\bM\033\017", /*psi*/
"*h", "\033\016o\b_\033\017", /*theta*/
"*n", "v\b)", /*nu*/
"*m", "\033\016V\b,\033\017", /*mu*/
"*l", "\033\016)\b?\033\017", /*lambda*/
"*i", "\033\016I\033\017", /*iota*/
"*z", "S\b\033\016Z\033\017", /*zeta*/
"*s", "o\b\'", /*sigma*/
"*d", "o\b\033\0165\033\017", /*delta*/
"*b", "\033\016b\033\017", /*beta*/
"*c", "\033\016e\bc\033\017", /*xi*/
"*y", "j\b\033\016C\033\017", /*eta*/
"*f", "\033\016O\bM\033\017", /*phi*/
"*u", "\033\016(\033\017", /*upsilon*/
"*k", "\033\016k\033\017", /*kappa*/
"*p", "T\b\033\016S\033\017", /*pi*/
"da", "\033\016U\033\017", /*down arrow*/
"*a", "\033\016A\033\017", /*alpha*/
"or", "|",
"*x", "l\b/", /*chi*/
"*e", "\033\016E\033\017", /*epsilon*/
"*o", "\033\016O\033\017", /*omicron*/
"<-", "\033\016[\033\017", /*left arrow*/
"*r", "\033\016R\033\017", /*rho*/
"ua", "\033\016Y\033\017", /*up arrow*/
"*t", "\033\016N\033\017", /*tau*/
"ul", "_",
"ru", "_",
"\\_", "_",
"*Q", "I\b\033\016(\033\017", /*Psi*/
"bs", "\033\016O\bJ\033\017", /*bell system sign*/
"if", "\033\016W\bX\033\017", /*infinity*/
"*g", "`\b/", /*gamma*/
"ip", "\033\016X\bF\033\017", /*improper superset*/
"pt", "\033\016A\033\017", /*proportional to*/
"rh", "\033\016\\\b]\033\017", /*right hand*/
"*w", "\033\016W\033\017", /*omega*/
"gr", "\033\016G\033\017", /*gradient*/
"*F", "I\033\016\bO\033\017", /*Phi*/
"*H", "O\b=", /*Theta*/
"*W", "O\b_", /*Omega*/
"cu", "\033\016V\033\017", /*cup (union)*/
"rn", "\033\016@\033\017", /*root en*/
"ts", "s", /*terminal sigma*/
"*L", "\033\016)\bK\033\017", /*Lambda*/
"\\-", "-",
"*G", "\033\016S\bK\033\017", /*Gamma*/
"is", "\033\016i\033\017", /*integral sign*/
"Sl", "l",
"*P", "\033\016t\b'\033\017", /*Pi*/
"sb", "\033\016Z\033\017", /*subset of*/
"sp", "\033\016X\033\017", /*superset of*/
"ap", "\033\016T\033\017", /*approximates*/
"pd", "o\b`", /*partial derivative*/
"*D", "\033\016H\033\017", /*Delta*/
"sr", "\033\016I\b'\033\017", /*square root*/
"*S", ">\b\033\016F\b@\033\017", /*Sigma*/
"~~", "\033\016T\bF\033\017", /*approx =*/
"*C", "\033\016_\bF\b@\033\017", /*Xi*/
"sl", "/",
"ca", "\033\016C\033\017", /*cap (intersection)*/
"U", "\033\016y\033\017", /*Upsilon*/
"no", "\033\016|\033\017", /*not*/
"rc", "|", /*right ceiling (rt of ")*/
"lt", "|", /*left top (of big curly)*/
"bv", "|", /*bold vertical*/
"lk", "|", /*left center of big curly bracket*/
"lb", "|", /*left bottom*/
"rt", "|", /*right top*/
"rk", "|", /*right center of big curly bracket*/
"rb", "|", /*right bot*/
"rf", "|", /*right floor (rb of ")*/
"lf", "|", /*left floor (left bot of big sq bract)*/
"lc", "|", /*left ceiling (lt of ")*/
"mu", "\033\016=\033\017", /*multiply*/
"di", "\033\016+\033\017", /*divide*/
"+-", "+\b_", /*plus-minus*/
"<=", "\033\016$\033\017", /*<=*/
">=", "\033\016^\033\017", /*>=*/
"==", "=\b_", /*identically equal*/
"!=", "\033\016*\033\017", /*not equal*/
"aa", "'",
"ga", "`",
"lh", "\033\016|\b[\033\017", /*left hand*/
"mo", "\033\016c\b_\033\017", /*member of*/
"es", "\033\016O\b/\033\017", /*empty set*/
"dd", "\033\016%\bM\033\017", /*dbl dagger*/
"br", "|", /*box rule*/
"vr", "|", /* vertical rule */
"ib", "\033\016Z\bF\033\017", /*improper subset*/
"ci", "\033\016O\033\017", /*circle*/
"eq", "=",
"pl", "+",
"mi", "-",
"12", "1/2",
"14", "1/4",
"34", "3/4",
"->", "\033\016]\033\017", /*right arrow*/
"sc", "g\b\033\016C\033\017", /*section mark*/
"**", "*",
"l.", ".",
"L.", ".",
"bx", "[\b]",
"ob", "o", /* open bullet */
"cd", ",", /* cedilla */
"..", "\033\016!\033\017", /* umlaut */
0, 0,
};