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; } } }