text: #include	<stdio.h>
  #include	<math.h>
  #include	"pic.h"
  #include	"y.tab.h"
  
  void arc_extreme(double, double, double, double, double, double);
  int quadrant(double x, double y);
  
  obj *arcgen(int type)	/* handles circular and (eventually) elliptical arcs */
  {
  	static double prevw = HT10;
  	static double prevh = HT5;
  	static double prevrad = HT2;
  	static int dtox[2][4] ={ 1, -1, -1, 1, 1, 1, -1, -1 };
  	static int dtoy[2][4] ={ 1, 1, -1, -1, -1, 1, 1, -1 };
  	static int dctrx[2][4] ={ 0, -1, 0, 1, 0, 1, 0, -1 };
  	static int dctry[2][4] ={ 1, 0, -1, 0, -1, 0, 1, 0 };
  	static int nexthv[2][4] ={ U_DIR, L_DIR, D_DIR, R_DIR, D_DIR, R_DIR, U_DIR, L_DIR };
  	double dx2, dy2, ht, phi, r, d;
  	int i, head, to, at, cw, invis, ddtype, battr;
  	obj *p, *ppos;
  	double fromx, fromy, tox, toy, fillval = 0;
  	Attr *ap;
  
  	prevrad = getfval("arcrad");
  	prevh = getfval("arrowht");
  	prevw = getfval("arrowwid");
  	fromx = curx;
  	fromy = cury;
  	head = to = at = cw = invis = ddtype = battr = 0;
  	for (i = 0; i < nattr; i++) {
  		ap = &attr[i];
  		switch (ap->a_type) {
  		case TEXTATTR:
  			savetext(ap->a_sub, ap->a_val.p);
  			break;
  		case HEAD:
  			head += ap->a_val.i;
  			break;
  		case INVIS:
  			invis = INVIS;
  			break;
  		case HEIGHT:	/* length of arrowhead */
  			prevh = ap->a_val.f;
  			break;
  		case WIDTH:	/* width of arrowhead */
  			prevw = ap->a_val.f;
  			break;
  		case RADIUS:
  			prevrad = ap->a_val.f;
  			break;
  		case DIAMETER:
  			prevrad = ap->a_val.f / 2;
  			break;
  		case CW:
  			cw = 1;
  			break;
  		case FROM:	/* start point of arc */
  			ppos = ap->a_val.o;
  			fromx = ppos->o_x;
  			fromy = ppos->o_y;
  			break;
  		case TO:	/* end point of arc */
  			ppos = ap->a_val.o;
  			tox = ppos->o_x;
  			toy = ppos->o_y;
  			to++;
  			break;
  		case AT:	/* center of arc */
  			ppos = ap->a_val.o;
  			curx = ppos->o_x;
  			cury = ppos->o_y;
  			at = 1;
  			break;
  		case UP:
  			hvmode = U_DIR;
  			break;
  		case DOWN:
  			hvmode = D_DIR;
  			break;
  		case RIGHT:
  			hvmode = R_DIR;
  			break;
  		case LEFT:
  			hvmode = L_DIR;
  			break;
  		case FILL:
  			battr |= FILLBIT;
  			if (ap->a_sub == DEFAULT)
  				fillval = getfval("fillval");
  			else
  				fillval = ap->a_val.f;
  			break;
  		}
  	}
  	if (!at && !to) {	/* the defaults are mostly OK */
  		curx = fromx + prevrad * dctrx[cw][hvmode];
  		cury = fromy + prevrad * dctry[cw][hvmode];
  		tox = fromx + prevrad * dtox[cw][hvmode];
  		toy = fromy + prevrad * dtoy[cw][hvmode];
  		hvmode = nexthv[cw][hvmode];
  	}
  	else if (!at) {
  		dx2 = (tox - fromx) / 2;
  		dy2 = (toy - fromy) / 2;
  		phi = atan2(dy2, dx2) + (cw ? -PI/2 : PI/2);
  		if (prevrad <= 0.0)
  			prevrad = dx2*dx2+dy2*dy2;
  		for (r=prevrad; (d = r*r - (dx2*dx2+dy2*dy2)) <= 0.0; r *= 2)
  			;	/* this kludge gets around too-small radii */
  		prevrad = r;
  		ht = sqrt(d);
  		curx = fromx + dx2 + ht * cos(phi);
  		cury = fromy + dy2 + ht * sin(phi);
  		dprintf("dx2,dy2=%g,%g, phi=%g, r,ht=%g,%g\n",
  			dx2, dy2, phi, r, ht);
  	}
  	else if (at && !to) {	/* do we have all the cases??? */
  		tox = fromx + prevrad * dtox[cw][hvmode];
  		toy = fromy + prevrad * dtoy[cw][hvmode];
  		hvmode = nexthv[cw][hvmode];
  	}
  	if (cw) {	/* interchange roles of from-to and heads */
  		double temp;
  		temp = fromx; fromx = tox; tox = temp;
  		temp = fromy; fromy = toy; toy = temp;
  		if (head == HEAD1)
  			head = HEAD2;
  		else if (head == HEAD2)
  			head = HEAD1;
  	}
  	p = makenode(type, 7);
  	arc_extreme(fromx, fromy, tox, toy, curx, cury);
  	p->o_val[0] = fromx;
  	p->o_val[1] = fromy;
  	p->o_val[2] = tox;
  	p->o_val[3] = toy;
  	if (cw) {
  		curx = fromx;
  		cury = fromy;
  	} else {
  		curx = tox;
  		cury = toy;
  	}
  	p->o_val[4] = prevw;
  	p->o_val[5] = prevh;
  	p->o_val[6] = prevrad;
  	p->o_attr = head | (cw ? CW_ARC : 0) | invis | ddtype | battr;
  	p->o_fillval = fillval;
  	if (head)
  		p->o_nhead = getfval("arrowhead");
  	dprintf("arc rad %g at %g %g from %g %g to %g %g head %g %g\n",
  		prevrad, p->o_x, p->o_y,
  		p->o_val[0], p->o_val[1], p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5]);
  	return(p);
  }
  
  /***************************************************************************
     bounding box of a circular arc             Eric Grosse  24 May 84
  
  Conceptually, this routine generates a list consisting of the start,
  end, and whichever north, east, south, and west points lie on the arc.
  The bounding box is then the range of this list.
      list = {start,end}
      j = quadrant(start)
      k = quadrant(end)
      if( j==k && long way 'round )  append north,west,south,east
      else
        while( j != k )
           append center+radius*[j-th of north,west,south,east unit vectors]
           j += 1  (mod 4)
      return( bounding box of list )
  The following code implements this, with simple optimizations.
  ***********************************************************************/
  
  
  void arc_extreme(double x0, double y0, double x1, double y1, double xc, double yc)
  			  /* start, end, center */
  {
  	/* assumes center isn't too far out */
  	double r, xmin, ymin, xmax, ymax;
  	int j, k;
  	x0 -= xc; y0 -= yc;	/* move to center */
  	x1 -= xc; y1 -= yc;
  	xmin = (x0<x1)?x0:x1; ymin = (y0<y1)?y0:y1;
  	xmax = (x0>x1)?x0:x1; ymax = (y0>y1)?y0:y1;
  	r = sqrt(x0*x0 + y0*y0);
  	if (r > 0.0) {
  		j = quadrant(x0,y0);
  		k = quadrant(x1,y1);
  		if (j == k && y1*x0 < x1*y0) {
  			/* viewed as complex numbers, if Im(z1/z0)<0, arc is big */
  			if( xmin > -r) xmin = -r; if( ymin > -r) ymin = -r;
  			if( xmax <  r) xmax =  r; if( ymax <  r) ymax =  r;
  		} else {
  			while (j != k) {
  				switch (j) {
  					case 1: if( ymax <  r) ymax =  r; break; /* north */
  					case 2: if( xmin > -r) xmin = -r; break; /* west */
  					case 3: if( ymin > -r) ymin = -r; break; /* south */
  					case 4: if( xmax <  r) xmax =  r; break; /* east */
  				}
  				j = j%4 + 1;
  			}
  		}
  	}
  	xmin += xc; ymin += yc;
  	xmax += xc; ymax += yc;
  	extreme(xmin, ymin);
  	extreme(xmax, ymax);
  }
  
  quadrant(double x, double y)
  {
  	if (     x>=0.0 && y> 0.0) return(1);
  	else if( x< 0.0 && y>=0.0) return(2);
  	else if( x<=0.0 && y< 0.0) return(3);
  	else if( x> 0.0 && y<=0.0) return(4);
  	else			   return 0;	/* shut up lint */
  }
  
  