void
eaterrors(int *r_errorc, Eptr **r_errorv)
{
Errorclass errorclass = C_SYNC;
for (;;) {
if (fgets(inbuffer, BUFSIZ, errorfile) == NULL)
break;
wordvbuild(inbuffer, &wordc, &wordv);
/*
* for convenience, convert wordv to be 1 based, instead
* of 0 based.
*/
wordv -= 1;
/*
* check for sunf77 errors has to be done before
* pccccom to be able to distingush between the two
*/
if ((wordc > 0) &&
(((errorclass = onelong()) != C_UNKNOWN) ||
((errorclass = cpp()) != C_UNKNOWN) ||
((errorclass = sunf77()) != C_UNKNOWN) ||
((errorclass = pccccom()) != C_UNKNOWN) ||
((errorclass = richieccom()) != C_UNKNOWN) ||
((errorclass = lint0()) != C_UNKNOWN) ||
((errorclass = lint1()) != C_UNKNOWN) ||
((errorclass = lint2()) != C_UNKNOWN) ||
((errorclass = lint3()) != C_UNKNOWN) ||
((errorclass = make()) != C_UNKNOWN) ||
((errorclass = f77()) != C_UNKNOWN) ||
((errorclass = pi()) != C_UNKNOWN) ||
((errorclass = ri()) != C_UNKNOWN) ||
((errorclass = troff()) != C_UNKNOWN) ||
((errorclass = mod2()) != C_UNKNOWN) ||
((errorclass = troff()) != C_UNKNOWN))) {
/* EMPTY */
} else {
errorclass = catchall();
}
if (wordc)
erroradd(wordc, wordv+1, errorclass, C_UNKNOWN);
}
#ifdef FULLDEBUG
printf("%d errorentrys\n", nerrors);
#endif
arrayify(r_errorc, r_errorv, er_head);
}
/*
* Eat all of the lines in the input file, attempting to categorize
* them by their various flavors
*/
void
eaterrors(int *r_errorc, Eptr **r_errorv)
{
Errorclass errorclass = C_SYNC;
char *line;
const char *inbuffer;
size_t inbuflen;
for (;;) {
if ((inbuffer = fgetln(errorfile, &inbuflen)) == NULL)
break;
line = Calloc(inbuflen + 1, sizeof(char));
memcpy(line, inbuffer, inbuflen);
line[inbuflen] = '\0';
wordvbuild(line, &cur_wordc, &cur_wordv);
/*
* for convenience, convert cur_wordv to be 1 based, instead
* of 0 based.
*/
cur_wordv -= 1;
if (cur_wordc > 0 &&
((( errorclass = onelong() ) != C_UNKNOWN)
|| (( errorclass = cpp() ) != C_UNKNOWN)
|| (( errorclass = gcc45ccom() ) != C_UNKNOWN)
|| (( errorclass = pccccom() ) != C_UNKNOWN)
|| (( errorclass = richieccom() ) != C_UNKNOWN)
|| (( errorclass = lint0() ) != C_UNKNOWN)
|| (( errorclass = lint1() ) != C_UNKNOWN)
|| (( errorclass = lint2() ) != C_UNKNOWN)
|| (( errorclass = lint3() ) != C_UNKNOWN)
|| (( errorclass = make() ) != C_UNKNOWN)
|| (( errorclass = f77() ) != C_UNKNOWN)
|| ((errorclass = pi() ) != C_UNKNOWN)
|| (( errorclass = ri() )!= C_UNKNOWN)
|| (( errorclass = mod2() )!= C_UNKNOWN)
|| (( errorclass = troff() )!= C_UNKNOWN))
) ;
else
errorclass = catchall();
if (cur_wordc)
erroradd(cur_wordc, cur_wordv+1, errorclass, C_UNKNOWN);
}
#ifdef FULLDEBUG
printf("%d errorentrys\n", nerrors);
#endif
arrayify(r_errorc, r_errorv, er_head);
}
static obj *
print_xform(int layer, obj *p) {
double r, ox, oy, dx, dy, x0, y0, x1, y1, M[4];
double b, tx0, ty0, tx1, ty1;
valtype *X;
obj *op, *q;
int n;
op = p;
if (p->o_layer != layer && p->o_type != BLOCK)
return p;
#if 0
if (p->o_type == TEXT) {
ox = Xformx(p->o_parent, 1, p->o_x, p->o_y);
oy = Xformy(p->o_parent, 0, p->o_x, p->o_y);
}
else {
#endif
ox = Xformx(p, 1, p->o_x, p->o_y);
oy = Xformy(p, 0, p->o_x, p->o_y);
#if 0
}
#endif
X = (valtype *)0;
if (p->o_type < TEXT && (p->o_attr & (FILLED | EDGED)))
chk_attrs (p);
switch (p->o_type) {
case TROFF:
n = p->o_nt1;
if (text[n].t_type & EQNTXT)
puteqn(ox, oy, text[n].t_type, atoi(text[n].t_val));
else
troff(text[n].t_val);
return p;
case BLOCK:
for (q = p->o_next; q != p->o_val[N_VAL].o; q = q->o_next)
if (q->o_type <= TEXT || q->o_nt2 > q->o_nt1)
q = print_xform(layer,q);
p = q;
break;
case PSFILE:
puteps(p);
/* CAREFUL!! THIS FLOWS THROUGH INTO BOX!! */
case BOX:
if (p->o_attr & (FILLED|EDGED)) {
if ((X = (valtype *)malloc(10*sizeof(valtype))) == NULL)
yyerror("out of room in print_xform");
r = p->o_val[N_VAL].f;
X[6].f = X[0].f = -(X[2].f = X[4].f = p->o_wid/2);
X[1].f = X[3].f = -(X[5].f = X[7].f = p->o_ht/2);
for (n = 0; n < 8; n += 2) {
x1 = ox + Linx(p, 0, X[n].f, X[n+1].f);
X[n+1].f = oy + Liny(p, 0, X[n].f, X[n+1].f);
X[n].f = x1;
}
X[n] = X[0]; X[++n] = X[1];
x1 = Linx(p, 0, r, 0.);
r = Liny(p, 0, r, 0.);
r = sqrt(x1 * x1 + r * r);
pline(4, 1, X, r);
}
break;
case CIRCLE:
case ELLIPSE:
if (p->o_attr & (FILLED|EDGED)) {
get_matrix(&x0, &y0, &x1, &y1);
x0 *= p->o_wid/2;
y0 *= p->o_wid/2;
x1 *= p->o_ht/2;
y1 *= p->o_ht/2;
ellipse(ox, oy, x0, y0, x1, y1, 0., 2*M_PI, 0);
}
break;
case SECTOR:
case ARC:
if (p->o_attr & (FILLED|EDGED)) {
register double ang1, ang2;
r = p->o_val[N_VAL+0].f;
x0 = p->o_val[N_VAL+2].f; /* starting point */
y0 = p->o_val[N_VAL+3].f;
x1 = p->o_val[N_VAL+4].f; /* ending point */
y1 = p->o_val[N_VAL+5].f;
ang1 = atan2(y0 - p->o_y, x0 - p->o_x);
ang2 = atan2(y1 - p->o_y, x1 - p->o_x);
/*
* If there are arrowheads and non-zero line thickness, we
* adjust the end points so the thick lines do not go all the
* way to the end of the arrows, obliterating the points.
*/
if (p->o_attr & HEAD12) {
dx = p->o_val[N_VAL+8].f;
dy = p->o_val[N_VAL+9].f;
if (p->o_weight > 0.) {
b = p->o_weight / 2 / dx;
b *= sqrt(dx*dx + 4*dy*dy);
b = 2. * atan2(b, r);
if (p->o_attr & HEAD1)
ang1 += b;
if (p->o_attr & HEAD2)
ang2 -= b;
}
}
tmp_xform(p);
line_weight = p->o_weight; /* use REAL weight here */
ellipse(p->o_x, p->o_y, r, 0., 0., r,
ang1, ang2, (int)p->o_type);
undo_tmpx();
/* This is a kludge. Because tmp_xform and undo_tmpx put the
* ellipse stuff (including a new_weight()) inside a gs/gr pair,
* the postscript line-weight is unchanged, but new_weight thinks
* it is set to line_weight. To get around this, we call a sub-
* that just resets the last_weight variable in plps.c.
*/
reset_line_weight();
if (p->o_attr & (HEAD1 | HEAD2))
arc_arrow(p);
}
break;
case LINE:
case ARROW:
case SPLINE:
if (p->o_attr & (FILLED|EDGED)) {
int c, i, nxy;
r = p->o_val[N_VAL+0].f;
x1 = Linx(p, 0, r, 0.);
r = Liny(p, 0, r, 0.);
r = sqrt(x1 * x1 + r * r);
nxy = p->o_val[N_VAL+3].f; /* segment count */
X = (valtype *)malloc((2*nxy+2)*sizeof(valtype));
if (X == NULL)
yyerror("out of room in print_xform");
for (i = 0, n = N_VAL+4; i <= 2 * nxy; ) {
register double xx = p->o_val[n++].f,
yy = p->o_val[n++].f;
X[i++].f = Xformx(p, 0, xx, yy);
X[i++].f = Xformy(p, 0, xx, yy);
}
x0 = X[0].f;
y0 = X[1].f;
x1 = X[i-2].f;
y1 = X[i-1].f;
tx0 = ty0 = tx1 = ty1 = 0.;
n = 2 * nxy - 2;
if (p->o_attr & HEAD12) {
get_matrix(M, M+1, M+2, M+3);
/* DBK: I added the fabs to eliminate sqrt errors
* and make it same as xprint.c. 9/20/90 */
dy = dx = sqrt(fabs(M[0]*M[3] - M[1]*M[2]));
dx *= p->o_val[N_VAL+1].f;
dy *= p->o_val[N_VAL+2].f;
if (p->o_weight > 0.) {
double linex, liney, a;
b = p->o_weight / 2 / p->o_val[N_VAL+1].f;
b *= sqrt(dx*dx + 4*dy*dy);
if (p->o_attr & HEAD2) {
linex = x1 - X[n].f;
liney = y1 - X[n+1].f;
a = b / sqrt(linex*linex + liney*liney);
tx1 = -a * linex;
ty1 = -a * liney;
x1 = X[n+2].f += tx1;
y1 = X[n+3].f += ty1;
}
if (p->o_attr & HEAD1) {
linex = x0 - X[2].f;
liney = y0 - X[3].f;
a = b / sqrt(linex*linex + liney*liney);
tx0 = -a * linex;
ty0 = -a * liney;
x0 = X[0].f += tx0;
y0 = X[1].f += ty0;
}
}
}
/* The first two args are just to give a direction to
* the second two. To make sure that the direction
* isn't reversed, adjust the first two by the same
* amount as we adjusted x1 and y1 above.
*/
c = (x0 == x1 && y0 == y1); /* flags closure */
if (nxy == 1)
line(X[0].f, X[1].f, X[2].f, X[3].f);
else if (p->o_type == SPLINE)
spline(nxy, c, X);
else
pline (nxy, c, X, r);
if (p->o_attr & HEAD2) {
tx1 += X[n].f;
ty1 += X[n+1].f;
arrow(tx1, ty1, x1, y1, dx, dy, 0.0, p->o_attr);
}
if (p->o_attr & HEAD1) {
tx0 += X[2].f;
ty0 += X[3].f;
arrow(tx0, ty0, x0, y0, dx, dy, 0.0, p->o_attr);
}
}
break;
case TEXT:
tmp_xform(p);
#if 0
dotext(ox, oy, p);
#else
dotext(p->o_x, p->o_y, p);
#endif
undo_tmpx();
return p;
}
if (X)
free(X);
if (op->o_nt1 < op->o_nt2)
objtext(ox, oy, op);
return p;
}
obj *
print_obj(int layer, obj *p) {
double r, ox, oy, x0, y0, x1, y1;
obj *op, *q;
int n;
op = p;
#if 0
/* 4/23/91 -- trying to understand BoundingBox problems */
if (redo_gbox) {
float bnd[4];
Gbox[2] = Gbox[3] = -(Gbox[0] = Gbox[1] = 32767);
for (q = objhead->o_next; q != objtail; q = q->o_next) {
if (q->o_type > TEXT)
continue;
get_tot_bounds(q, bnd, 1);
/* get_bounds(q, bnd, 1); */
track_bounds (bnd[0], bnd[1], bnd[2], bnd[3]);
if (q->o_type == BLOCK)
q = q->o_val[N_VAL].o;
}
redo_gbox = 0;
}
#endif
openpl("");
if (p->o_type != BLOCK && p->o_layer != layer)
return p;
if (p->o_type <= TEXT && (p->o_mxx!=1 || p->o_myy!=1 || p->o_mxy!=0 ||
p->o_myx!=0 || p->o_mxt!=0 || p->o_myt!=0))
return print_xform(layer,p);
ox = p->o_x;
oy = p->o_y;
if (p->o_type < TEXT && (p->o_attr & (FILLED | EDGED)))
chk_attrs (p);
switch (p->o_type) {
case TROFF:
n = p->o_nt1;
if (text[n].t_type & EQNTXT)
puteqn(ox, oy, text[n].t_type, atoi(text[n].t_val));
else
troff(text[n].t_val);
return p;
case BLOCK:
for (q = p->o_next; q != p->o_val[N_VAL].o; q = q->o_next)
if (q->o_type <= TEXT || q->o_nt2 > q->o_nt1)
q = print_obj(layer,q);
p = q;
break;
case PSFILE:
puteps(p);
/* CAREFUL!! THIS FLOWS THROUGH INTO BOX!! */
case BOX:
if (p->o_attr & (FILLED|EDGED)) {
x0 = ox - p->o_wid/2; x1 = ox + p->o_wid/2;
y0 = oy - p->o_ht/2; y1 = oy + p->o_ht/2;
r = p->o_val[N_VAL].f;
box(x0, y0, x1, y1, r);
}
break;
case CIRCLE:
case ELLIPSE:
if (p->o_attr & (FILLED|EDGED))
ellipse(ox,oy,p->o_wid/2,0.,0.,p->o_ht/2,0.,2*M_PI,0);
break;
case SECTOR:
case ARC:
if (p->o_attr & (FILLED|EDGED)) {
register double ang1, ang2;
if (p->o_attr & HEAD12) {
print_xform(layer, p);
break;
}
r = p->o_val[N_VAL+0].f;
x0 = p->o_val[N_VAL+2].f; /* starting point */
y0 = p->o_val[N_VAL+3].f;
x1 = p->o_val[N_VAL+4].f; /* ending point */
y1 = p->o_val[N_VAL+5].f;
ang1 = atan2(y0-oy, x0-ox);
ang2 = atan2(y1-oy, x1-ox);
ellipse(ox, oy, r, 0., 0., r, ang1, ang2, p->o_type);
}
break;
case LINE:
case ARROW:
case SPLINE:
if (p->o_attr & (FILLED|EDGED)) {
int c, nxy;
if (p->o_attr & HEAD12) {
print_xform(layer, p);
break;
}
r = p->o_val[N_VAL+0].f;
nxy = p->o_val[N_VAL+3].f; /* segment count */
x0 = p->o_val[N_VAL+4].f; /* first point */
y0 = p->o_val[N_VAL+5].f;
x1 = p->o_val[N_VAL+4+2*nxy].f; /* last point */
y1 = p->o_val[N_VAL+5+2*nxy].f;
c = (x0 == x1 && y0 == y1); /* flags closure */
if (nxy == 1)
line(x0, y0, x1, y1);
else if (p->o_type == SPLINE)
spline(nxy, c, &p->o_val[N_VAL+4]);
else
pline (nxy, c, &p->o_val[N_VAL+4], r);
}
break;
}
if (op->o_nt1 < op->o_nt2)
objtext(ox, oy, op);
return p;
}
print()
{
obj *p;
int i, j, k, m;
float x0, y0, x1, y1, ox, oy, dx, dy, ndx, ndy;
for (i = 0; i < nobj; i++) {
p = objlist[i];
ox = p->o_x;
oy = p->o_y;
if (p->o_count >= 1)
x1 = p->o_val[0];
if (p->o_count >= 2)
y1 = p->o_val[1];
m = p->o_mode;
switch (p->o_type) {
case TROFF:
troff(text[p->o_nt1].t_val);
break;
case BOX:
case BLOCK:
move(ox, oy);
dotext(p); /* if there are any text strings */
x0 = ox - x1 / 2;
y0 = oy - y1 / 2;
x1 = ox + x1 / 2;
y1 = oy + y1 / 2;
if (p->o_attr & INVIS || p->o_type == BLOCK)
; /* nothing at all */
else if (p->o_attr & (DOTBIT|DASHBIT))
dotbox(x0, y0, x1, y1, p->o_attr, p->o_ddval);
else
box(x0, y0, x1, y1);
if (ishor(m))
move(isright(m) ? x1 : x0, oy); /* right side */
else
move(ox, isdown(m) ? y0 : y1); /* bottom */
break;
case BLOCKEND:
break;
case CIRCLE:
move(ox, oy);
dotext(p);
if ((p->o_attr & INVIS) == 0)
circle(ox, oy, x1);
if (ishor(m))
move(ox + isright(m) ? x1 : -x1, oy);
else
move(ox, oy + isup(m) ? x1 : -x1);
break;
case ELLIPSE:
move(ox, oy);
dotext(p);
if ((p->o_attr & INVIS) == 0)
ellipse(ox, oy, x1, y1);
if (ishor(m))
move(ox + isright(m) ? x1 : -x1, oy);
else
move(ox, oy - isdown(m) ? y1 : -y1);
break;
case ARC:
move(ox, oy);
dotext(p);
if (p->o_attr & HEAD1)
arrow(x1 - (y1 - oy), y1 + (x1 - ox),
x1, y1, p->o_val[4], p->o_val[5], p->o_val[5]/p->o_val[6]/2, p->o_nhead);
if (p->o_attr & INVIS)
/* probably wrong when it's cw */
move(x1, y1);
else
arc(ox, oy, x1, y1, p->o_val[2], p->o_val[3]);
if (p->o_attr & HEAD2)
arrow(p->o_val[2] + p->o_val[3] - oy, p->o_val[3] - (p->o_val[2] - ox),
p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5], -p->o_val[5]/p->o_val[6]/2, p->o_nhead);
if (p->o_attr & CW_ARC)
move(x1, y1); /* because drawn backwards */
break;
case LINE:
case ARROW:
case SPLINE:
move((ox + x1)/2, (oy + y1)/2); /* center */
dotext(p);
if (p->o_attr & HEAD1)
arrow(ox + p->o_val[5], oy + p->o_val[6], ox, oy, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
if (p->o_attr & INVIS)
move(x1, y1);
else if (p->o_type == SPLINE)
spline(ox, oy, p->o_val[4], &p->o_val[5], p->o_attr & (DOTBIT|DASHBIT), p->o_ddval);
else {
dx = ox;
dy = oy;
for (k=0, j=5; k < p->o_val[4]; k++, j += 2) {
ndx = dx + p->o_val[j];
ndy = dy + p->o_val[j+1];
if (p->o_attr & (DOTBIT|DASHBIT))
dotline(dx, dy, ndx, ndy, p->o_attr, p->o_ddval);
else
line(dx, dy, ndx, ndy);
dx = ndx;
dy = ndy;
}
}
if (p->o_attr & HEAD2) {
dx = ox;
dy = oy;
for (k = 0, j = 5; k < p->o_val[4] - 1; k++, j += 2) {
dx += p->o_val[j];
dy += p->o_val[j+1];
}
arrow(dx, dy, x1, y1, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
}
break;
case MOVE:
case TEXT:
move(ox, oy);
dotext(p);
break;
}
}
}
