Merge branch 'arkkra' into shiny

[mup] / mup / mup / phrase.c

/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2005 by Arkkra Enterprises */
/* All rights reserved */

/* functions to determine the curves that make up phrase marks,
 * ties and slurs. */

#include "defines.h"
#include "structs.h"
#include "globals.h"

/* distance to the top/bottom of a V-shape (indicating a bend) relative to
 * the line connecting the endpoints of the V */
#define V_HEIGHT (2.7 * Stepsize)

/* How much bulge to allow in curves. There are three slightly different
 * approaches that are tried, each succeeding approach allows more bulge
 * in a more despearate attempt to get a reasonable curve. */
#define MINBULGE	(1.2)
#define MAXBULGE	(2.1)
#define MIN2BULGE	(1.4)
#define MAX2BULGE	(4.1)
#define MIN3BULGE	(1.8)
#define MAX3BULGE	(5.6)

/* We'd normally want curves to begin and end (in the x direction) exactly in
 * the middle of their note. But if one curve ends and another begins on
 * the same note, the curve endpoints would collide, which could look bad.
 * So we always offset the endpoints by a tiny amount (ends end a little
 * west of center, and beginnings begin a little east) so they don't touch.
 * This is the amount they are shifted from center.
 */
#define XOFFSET4CURVE	(0.75 * Stdpad)

/* Curves must be at least this far away from notes */
#define CLEARANCE	(3.0 * Stdpad)

/* try_bulge() is called lots of times in a row with mostly the same values,
 * and it needs lots of values, so it is convenient to put them in a struct,
 * and just pass a pointer to it */
struct TRYBULGE {
	struct MAINLL *mll_p;		/* STUFF hangs off here */
	struct GRPSYL *begin_gs_p;	/* group at left end of curve */
	struct GRPSYL *end_gs_p;	/* group at right end of curve */
	int place;			/* PL_*  */
	struct CRVLIST *curvelist_p;	/* points to beginning of curve */
	struct CRVLIST *endlist_p;	/* points to end of curve */
	double xlen;			/* distance to midpoint */
	double ylen;			/* how much bulge to add */
	double sintheta;		/* for rotation from horizontal */
	double costheta;
	double minbulge;		/* first bulge factor to try */
	double maxbulge;		/* last bulge to try before giving up */
	int leftcount;			/* value is returned here. Count of
					 * how many "stick-outs" are near the
					 * left end of the curve */
	int rightcount;			/* similar for right end */
};

static int nowhere_slide P((struct STUFF *stuff_p));
static void do_nowhere P((struct STUFF *stuff_p, double x1, double y1,
		double x2, double y2));
static void curve_points P((struct MAINLL *mll_p, struct STUFF *stuff_p,
		int is_phrase));
static double inner_adj P((struct GRPSYL *gs_p, struct NOTE *note_p,
		double y_adj, int place));
static double stick_out P((struct TRYBULGE *info_p));
static double try_bulge P((struct TRYBULGE *info_p));
static double tieslurx P((struct GRPSYL *gs_p, struct NOTE *note_p, int place));
static struct MAINLL *next_staff P((int staff, struct MAINLL *mll_p));
static void redo_steep P((struct CRVLIST *first_p, struct CRVLIST *last_p,
		int place));
static void final_touches P((struct MAINLL *mll_p, struct GRPSYL *begin_gs_p,
		struct GRPSYL *end_gs_p, struct CRVLIST *crvlist_p, int place));
static double eff_tupext P((struct GRPSYL * gs_p, struct STAFF *staff_p, int side));
static int bulge_direction P((struct MAINLL *mll_p, struct GRPSYL *gs1_p,
		int note_index, int curveno));
\f

/* figure out what points are needed for a phrase mark */
/* attach a linked list of x,y coordinates that show where to draw the curve.
 * The curve will be out of the way of any groups within the phrase. */

void
phrase_points(mll_p, stuff_p)

struct MAINLL *mll_p;		/* MAINLL that stuff_p hangs off of */
struct STUFF *stuff_p;		/* info about the phrase mark */

{
	curve_points(mll_p, stuff_p, YES);
}
\f

/* figure out what points are needed for a tie or slur mark */

void
tieslur_points(mll_p, stuff_p)

struct MAINLL *mll_p;		/* MAINLL that stuff_p hangs off of */
struct STUFF *stuff_p;		/* info about the phrase mark */

{
	/* if slide to/from nowhere in particular, do that */
	if (nowhere_slide(stuff_p) == YES) {
		return;
	}

	curve_points(mll_p, stuff_p, NO);
}
\f

/* determine the 3 points that define a V_shaped bend indicator on the tabnote
 * staff associated with a tab staff, and put them in the stuff crvlist */

void
bend_points(mll_p, stuff_p)

struct MAINLL *mll_p;
struct STUFF *stuff_p;

{
	struct CRVLIST *first_point_p, *last_point_p;	/* the beginning
				 * and end points of the curve */
	struct CRVLIST *mid_point_p;		/* middle of the V-shape */
	struct CRVLIST *one2discard_p;		/* a point to discard */
	double midx, midy;			/* midpoint between the ends */
	double v_height;			/* V_HEIGHT, or less than
						 * that for narrow V's */
	double xlen;				/* to help find v_height */
	double slope;				/* of perpendicular line from
						 * (midx, midy) to the point
						 * of the V, v_height away. */


	/* first figure everything out as if it were a normal slur */
	curve_points(mll_p, stuff_p, NO);

	/* Now make into V-shaped curve.
	 * First throw away the inner points that we had found.
	 * It's a bit unfortunate to do all that work, then throw it
	 * away, but the curve_point() function that finds all the points
	 * also does lots of other good things that we want, so rather than
	 * make it more complicated than it already is by having it know
	 * about bends, we just save the things it did that help us here.
	 */
	first_point_p = stuff_p->crvlist_p;
	for (last_point_p = first_point_p->next;
			last_point_p->next != (struct CRVLIST *) 0;  ) {
		one2discard_p = last_point_p;
		last_point_p = last_point_p->next;
		FREE(one2discard_p);
	}

	/* get a midpoint struct and stitch it into the list */
	MALLOC(CRVLIST, mid_point_p, 1);
	first_point_p->next = mid_point_p;
	last_point_p->prev = mid_point_p;
	mid_point_p->prev = first_point_p;
	mid_point_p->next = last_point_p;

	/* find the midpoint of the line between the endpoints */
	midx = (last_point_p->x + first_point_p->x) / 2.0;
	midy = (last_point_p->y + first_point_p->y) / 2.0;

	/* get height. Use V_HEIGHT, except adjust for narrow V's */
	xlen = fabs(last_point_p->x - first_point_p->x);
	if (xlen < 2.0 * V_HEIGHT) {
		v_height = 0.35 * V_HEIGHT;
	}
	else if (xlen < 3.5 * V_HEIGHT) {
		v_height = 0.65 * V_HEIGHT;
	}
	else {
		v_height = V_HEIGHT;
	}

	/* if the y's of the endpoints are equal or nearly so, finding the
	 * midpoint of the V is easy: the x is midx, and the y is midy offset
	 * by v_height in the appropriate direction */
	if (fabs(last_point_p->y - first_point_p->y) < 0.001) {
		mid_point_p->x = midx;
		mid_point_p->y = midy + v_height *
				(stuff_p->place == PL_ABOVE ? 1.0 : -1.0);
		return;
	}

	/* find the slope of the perpendicular */
	slope = (first_point_p->x - last_point_p->x) /
				(last_point_p->y - first_point_p->y);

	/* we want the length of the perpendicular line from (midx, midy)
	 * to the point at the top (or bottom) of the V to be v_height.
	 * Using that line as the hypotenuse of a triangle, we know that
	 * we can find the x and y relative to (midx, midy) by using
	 * Pythagorean   x^2 + y^2 = v_height^2. Furthermore, we calculated 
	 * the slope of the line earlier, and knowing that slope = y/x,
	 * we now solve 2 equations in 2 unknowns:
	 *	x^2 + y^2 = v_height^2
	 *	slope = y / x
	 * Rearranging the first equation and substituing (slope * x) for y:
	 *	x^2 + (slope * x)^2 = v_height^2
	 * solve for x:
	 * 	(1 + slope^2) * x^2 = v_height^2
	 *	x = sqrt( v_height^2 / (1 + slope^2))
	 * Then having found x, solve the second equation for y.
	 *	y = x * slope
	 * Adjust for being relative to (midx, midy) and for bend direction
	 * and slope direction, and we are done.
	 */
	mid_point_p->x = (sqrt((v_height * v_height) / (1.0 + (slope * slope))))
			* (first_point_p->y > last_point_p->y ? 1.0 : -1.0)
			* (stuff_p->place == PL_ABOVE ? 1.0 : -1.0);
	mid_point_p->y = (slope * mid_point_p->x) + midy;
	mid_point_p->x += midx;
}
\f

/* determine the 2 points that define a line indicating a slide for a
 * tab or tabnote staff, and put the points in the stuff crvlist */

void
tabslur_points(mll_p, stuff_p)

struct MAINLL *mll_p;
struct STUFF *stuff_p;

{
	struct CRVLIST *curvelist_p;
	struct GRPSYL *beggrp_p;
	struct GRPSYL *endgrp_p;
	struct NOTE *begnote_p;
	struct NOTE *endnote_p;
	float slant;		/* 0, 1 or -1 to show slant direction */
	int acc1, acc2;		/* effective accidentals on the 2 groups,
				 * -2 to +2 */
	int n, st;		/* index through notelist and slurtolist */


	/* if slide to/from nowhere in particular, do that */
	if (nowhere_slide(stuff_p) == YES) {
		return;
	}

	/* find the end note */
	if (stuff_p->carryin == YES) {
		/* on carryin, beggrp_p is really the ending group,
		 * and the previous group is the real beggrp_p */
		endgrp_p = stuff_p->beggrp_p;
		endnote_p = stuff_p->begnote_p;
		beggrp_p = prevgrpsyl(stuff_p->beggrp_p, &mll_p);

		/* go through all the notes in the previous group,
		 * to find the one that has a slide to the note being
		 * carried into. If there is more than one, use the first
		 * one we find. */
		for (n = 0; n < beggrp_p->nnotes; n++) {
			for (st = 0; st < beggrp_p->notelist[n].nslurto; st++) {
				if (endnote_p->letter ==
				  beggrp_p->notelist[n].slurtolist[st].letter
				  && (is_tab_staff(endgrp_p->staffno) == YES
				  || endnote_p->octave ==
				  beggrp_p->notelist[n].slurtolist[st].octave)) {
					/* found the one sliding to us */
					break;
				}
			}
			if (st < beggrp_p->notelist[n].nslurto) {
				/* found it, so need to jump out */
				break;
			}
		}
		if (n == beggrp_p->nnotes) {
			pfatal("can't find note being slid from");
		}
		begnote_p = &(beggrp_p->notelist[n]);
	}
	else {
		beggrp_p = stuff_p->beggrp_p;
		begnote_p = stuff_p->begnote_p;
		if ((endgrp_p = nextgrpsyl(stuff_p->beggrp_p, &mll_p))
						== (struct GRPSYL *) 0) {
			pfatal("failed to find next group in tabslur_points");
		}
		endnote_p = find_matching_note (endgrp_p,
				stuff_p->begnote_p->slurtolist
				[stuff_p->curveno].letter,
				stuff_p->begnote_p->slurtolist
				[stuff_p->curveno].octave, "slide");

		if (endnote_p == (struct NOTE *) 0) {
			pfatal("failed to find endnote in tabslur_points");
		}
	}

	if (is_tab_staff(mll_p->u.staff_p->staffno) == YES) {
		/* figure out whether to slant up or down based on whether
		 * first or second fret is higher */
		if (begnote_p->FRETNO > endnote_p->FRETNO) {
			slant = 1;
		}
		else {
			slant = -1;
		}
	}
	else {
		/* on non-tab staff, usually the line goes to the midpoint of
		 * the note head, so no need to adjust, so set slant to 0 */
		slant = 0;

		/* there are two exceptions: first, if both notes have the same
		 * letter/octave, but different accidentals, then we have to
		 * determine the slant based on the accidental. */
		if (begnote_p->letter == endnote_p->letter
				&& begnote_p->octave == endnote_p->octave) {

			/* if the accidental on the begin note is higher than
			 * the accidental on the end note, then it slants
			 * down from left to right, and vice versa. Get the
			 * effective accidental on each group,
			 * accounting for key signature, accidentals earlier
			 * in the measure, etc. */
			acc1 = eff_acc(beggrp_p, begnote_p, mll_p);
			acc2 = eff_acc(endgrp_p, endnote_p, mll_p);

			/* error if the slide is between identical notes */
			if (acc1 == acc2) {
				l_ufatal(endgrp_p->inputfile,
						endgrp_p->inputlineno,
						"can't slide to the same note");
			}
			else if (acc1 > acc2) {
				slant = 1;
			}
			else {
				slant = -1;
			}
		}

		/* second exception: if the slide is carried in, then it needs
		 * to be slanted, so figure out which way */
		if (stuff_p->carryin == YES) {
#ifdef __STDC__
			switch(notecomp( (const void *) begnote_p,
						(const void *) endnote_p)) {
#else
			switch(notecomp( (char *) begnote_p, (char *) endnote_p)) {
#endif
			case 1:
				slant = 0.5;
				break;
			case -1:
				slant = -0.5;
				break;
			default:
				/* same note, so have to use accidental as
				 * the deciding factor */
				acc1 = eff_acc(beggrp_p, begnote_p, mll_p);
				acc2 = eff_acc(endgrp_p, endnote_p, mll_p);

				/* error if the slide is
				 * between identical notes */
				if (acc1 == acc2) {
					l_ufatal(endgrp_p->inputfile,
						endgrp_p->inputlineno,
						"can't slide to the same note");
				}
				else if (acc1 > acc2) {
					slant = 0.5;
				}
				else {
					slant = -0.5;
				}
				break;
			}
		}
	}

	/* find beginning point of line */
	MALLOC(CRVLIST, curvelist_p, 1);
	curvelist_p->prev = (struct CRVLIST *) 0;
	if (stuff_p->carryin == YES) {
		/* start a bit west of the end note */
		curvelist_p->x = stuff_p->beggrp_p->c[AX] +
			notehorz(stuff_p->beggrp_p, stuff_p->begnote_p, RW)
			- 3.0 * Stepsize;
		curvelist_p->y = endnote_p->c[RY] + (slant * Stepsize);
	}
	else {
		/* start just beyond east of begin note */
		curvelist_p->x = begnote_p->c[AE] + Stdpad;
		curvelist_p->y = stuff_p->begnote_p->c[RY] + (slant * Stepsize);
	}

	/* end point of line */
	MALLOC(CRVLIST, curvelist_p->next, 1);
	curvelist_p->next->prev = curvelist_p;
	curvelist_p->next->next = (struct CRVLIST *) 0;
	if (stuff_p->carryout == YES) {
		/* extend to near end of score */
		curvelist_p->next->x = PGWIDTH - eff_rightmargin(mll_p) - Stepsize;
	}
	else  {
		/* go to just before west of end note */
		curvelist_p->next->x = endgrp_p->c[AX] +
				notehorz(endgrp_p, endnote_p, RW) - Stdpad;
	}
	curvelist_p->next->y = endnote_p->c[RY] - (slant * Stepsize);

	/* attach to stuff */
	stuff_p->crvlist_p = curvelist_p;

	/* place doesn't really make sense, so set arbitrarily */
	stuff_p->place = PL_ABOVE;
}
\f

/* if the slide for given tabslur stuff is to/from nowhere in particular,
 * then handle that here and return YES. Otherwise return NO. */

static int
nowhere_slide(stuff_p)

struct STUFF *stuff_p;

{
	double boundary;	/* east or west boundary of note, with
				 * the slide included */
	double adjust = 0.0;	/* to move the slanted line slightly when
				 * there is a note on the other side of
				 * the stem that is in the way. */
	struct GRPSYL *gs_p;
	struct NOTE *note_p;
	int n;
	float slidexlen;	/* SLIDEXLEN * Staffscale */


	if (stuff_p->curveno < 0) {
		return(NO);
	}

	if (stuff_p->begnote_p->nslurto == 0) {
		return(NO);
	}

	/* find which note it is in the chord, so check later for possible
	 * collisions between the slide and a neighboring note */
	gs_p = stuff_p->beggrp_p;
	note_p = stuff_p->begnote_p;
	for (n = 0; n < gs_p->nnotes; n++) {
		if ( &(gs_p->notelist[n]) == note_p) {
			break;
		}
	}
	if (n == gs_p->nnotes) {
		pfatal("couldn't find note in chord for slide");
	}

	slidexlen = SLIDEXLEN * Staffscale;

	/* for each type, find the outer boundary of the note with the
	 * nowhere slide included and draw a line from there towards the
	 * note, slanted the appropriate direction */
	switch (stuff_p->begnote_p->slurtolist[stuff_p->curveno].octave) {

	case IN_UPWARD:
		boundary = stuff_p->beggrp_p->c[AX] +
			notehorz(stuff_p->beggrp_p, stuff_p->begnote_p, RW);
		/* If there is a note one stepsize below this note, and it's
		 * to the left of the stem while the target note is on the
		 * right side, move the slide up a
		 * tiny bit so it doesn't get swallowed up in that other note
		 * and/or a slide coming into it.
		 * If we're sliding into the middle of a cluster with
		 * wrong-side notes both above and below the target note, it
		 * will still get somewhat swallowed, but that's unlikely to
		 * happen very often, and if it does, this is still about the
		 * best we can manage in that case. */
		n++;
		if (n < gs_p->nnotes && gs_p->notelist[n].stepsup
				== note_p->stepsup - 1 &&
				gs_p->notelist[n].c[AX] < note_p->c[AX]) {
			adjust = Stdpad;
		}
		do_nowhere(stuff_p,
			boundary, stuff_p->begnote_p->c[RY] - Stepsize + adjust,
			boundary + slidexlen, stuff_p->begnote_p->c[RY] + adjust);
		return(YES);

	case IN_DOWNWARD:
		boundary = stuff_p->beggrp_p->c[AX] +
			notehorz(stuff_p->beggrp_p, stuff_p->begnote_p, RW);
		/* if there is a note just above that we might
		 * collide with, adjust to dodge it. */
		n--;
		if (n >= 0 && gs_p->notelist[n].stepsup
				== note_p->stepsup + 1 &&
				gs_p->notelist[n].c[AX] < note_p->c[AX]) {
			adjust = Stdpad;
		}
		do_nowhere(stuff_p,
			boundary, stuff_p->begnote_p->c[RY] + Stepsize - adjust,
			boundary + slidexlen, stuff_p->begnote_p->c[RY] - adjust);
		return(YES);

	case OUT_UPWARD:
		boundary = stuff_p->beggrp_p->c[AX] +
			notehorz(stuff_p->beggrp_p, stuff_p->begnote_p, RE);
		/* If note just above this one that we might collide with,
		 * dodge it */
		n--;
		if (n >= 0 && gs_p->notelist[n].stepsup
				== note_p->stepsup + 1 &&
				gs_p->notelist[n].c[AX] > note_p->c[AX]) {
			adjust = Stdpad;
		}
		do_nowhere(stuff_p,
			boundary - slidexlen, stuff_p->begnote_p->c[RY] - adjust,
			boundary, stuff_p->begnote_p->c[RY] + Stepsize - adjust);
		return(YES);

	case OUT_DOWNWARD:
		boundary = stuff_p->beggrp_p->c[AX] +
			notehorz(stuff_p->beggrp_p, stuff_p->begnote_p, RE);
		/* If note below we might collide with, dodge it */
		n++;
		if (n < gs_p->nnotes && gs_p->notelist[n].stepsup
				== note_p->stepsup - 1 &&
				gs_p->notelist[n].c[AX] > note_p->c[AX]) {
			adjust = Stdpad;
		}
		do_nowhere(stuff_p,
			boundary - slidexlen, stuff_p->begnote_p->c[RY] + adjust,
			boundary, stuff_p->begnote_p->c[RY] - Stepsize + adjust);
		return(YES);

	default:
		return(NO);
	}
}
\f

/* make a CRVLIST with the 2 given points and put it in the given stuff */

static void
do_nowhere(stuff_p, x1, y1, x2, y2)

struct STUFF *stuff_p;
double x1, y1, x2, y2;

{
	MALLOC(CRVLIST, stuff_p->crvlist_p, 1);
	stuff_p->crvlist_p->x = x1;
	stuff_p->crvlist_p->y = y1;
	MALLOC(CRVLIST, stuff_p->crvlist_p->next, 1);
	stuff_p->crvlist_p->next->x = x2;
	stuff_p->crvlist_p->next->y = y2;

	stuff_p->crvlist_p->prev = stuff_p->crvlist_p->next->next
							= (struct CRVLIST *) 0;
	stuff_p->crvlist_p->next->prev = stuff_p->crvlist_p;

	/* place is not really relevant, but put something in it */
	stuff_p->place = PL_ABOVE;
}
\f

/* Figure out what points are needed for a curve, either a phrase mark
 * or a tie/slur, or a bend.
 * First it figures out where the endpoints should be,
 * then finds a curve that will be beyond all the groups that it covers.
 */

static void
curve_points(mll_p, stuff_p, is_phrase)

struct MAINLL *mll_p;		/* MAINLL that stuff_p hangs off of */
struct STUFF *stuff_p;		/* info about the phrase mark or tie/slur */
int is_phrase;			/* YES if phrase, NO if tie or slur */

{
	struct GRPSYL *begin_gs_p;	/* curve starts on this group */
	struct GRPSYL *end_gs_p;	/* curve ends on this group */
	struct NOTE *begnote_p;		/* first note for tie/slur */
	struct NOTE *endnote_p = 0;	/* last note of tie/slur */
	int place;			/* bend PL_ABOVE or PL_BELOW */
	int side;			/* RN or RS */
	int side_adj;			/* AN or AS. This field is used to
					 * adjust for nested phrase marks */
	double bulgeval;		/* bulge factor of curve */
	int try;			/* count of tries to get a good curve */
	int found_good;			/* YES if found a good-looking curve */
	struct TRYBULGE tb;		/* Info for try_bulge() */
	struct TRYBULGE *try_p;		/*  = &tb */
	float sign;			/* based on if curve is up or down */
	struct CRVLIST *curvelist_p;	/* beginning of curve */
	struct CRVLIST *endlist_p;	/* last point of curve */
	struct CRVLIST *new_p;		/* point to add to list of points */
	struct MAINLL *bar_mll_p = 0;	/* to find bar or pseudo bar */
	float length;			/* length of curve */
	float ylen;		/* length of segment in y direction before
				 * rotation */
	float y_adj = 0.0, y2_adj = 0.0;/* if moved because was an end note */
	char *name;		/* "phrase" or "tie/slur" */
	float sintheta, costheta;/* for rotating */


	debug(32, "curve_points lineno %d", stuff_p->inputlineno );

	/* get short names to groups and notes we'll use a lot */
	begin_gs_p = stuff_p->beggrp_p;
	end_gs_p = stuff_p->endgrp_p;
	begnote_p = stuff_p->begnote_p;
	
	/* figure out what string ("phrase" or "tie/slur") to use for error
	 * messages and make sure begin group is not null */
	if (is_phrase == YES) {
		name = "phrase";
		if ( (begin_gs_p == (struct GRPSYL *) 0)
				|| (end_gs_p == (struct GRPSYL *) 0) ) {
			pfatal("no group associated with phrase");
		}
	}
	else {
		int indx;

		name = "tie/slur";
		if (begin_gs_p == (struct GRPSYL *) 0) {
			pfatal("no group associated with tie/slur");
		}
		/* figure out which direction to bend the tie/slur */
		if (stuff_p->carryin == YES) {
			struct MAINLL *m_p;
			struct GRPSYL *g_p;
			struct STUFF *st_p;

			/* Need to base bend direction on the
			 * group/note/curve that was the carryout,
			 * otherwise the carryin and carryout could have
			 * different bend directions.
			 * We also need the costuff_p to get
			 * any user override of bend direction.
			 *
			 * Find the MAINLL pointing to the STAFF that
			 * should contain the costuff. Use prevgrpsyl,
			 * since it knows how to deal with endings,
			 * but we're really interested in the MAINLL
			 * pointing to the GRPSYL
			 * rather than the GRPSYL itself.
			 */

			/* First make sure we have the first group
			 * in the measure. */
			for (g_p = begin_gs_p; g_p->prev != 0; g_p = g_p->prev) {
				;
			}

			/* Now find the MAINLL pointing to the prev meas */
			m_p = mll_p;
			(void) prevgrpsyl(g_p, &m_p);
			if (m_p == 0 || m_p->str != S_STAFF) {
				pfatal("failed to find costaff_p's mainll");
			}

			/* Locate the costuff. We could just use
			 * stuff_p->costuff_p, but by searching for it here,
			 * we double check that we really found the right
			 * MAINLL, and can pfatal if not. */
			for (st_p = m_p->u.staff_p->stuff_p; st_p != 0;
							st_p = st_p->next) {
				if (st_p == stuff_p->costuff_p) {
					break;
				}
			}
			if (st_p == 0) {
				pfatal("failed to find costaff_p from mainll");
			}

			indx = st_p->begnote_p - &(st_p->beggrp_p->notelist[0]);
			stuff_p->place = (bulge_direction(m_p, st_p->beggrp_p,
				indx, st_p->curveno) == UP
				? PL_ABOVE : PL_BELOW);
		}
		else {
			indx = begnote_p - &(begin_gs_p->notelist[0]);
			stuff_p->place = (bulge_direction(mll_p, begin_gs_p,
				indx, stuff_p->curveno) == UP
				? PL_ABOVE : PL_BELOW);
		}
	}

	place = stuff_p->place;

	/* determine whether to use north or south of groups, and what sign to
	 * use to get the bends in the correct direction */
	if (place == PL_ABOVE) {
		side = RN;
		side_adj = AN;
		sign = 1.0;
	}
	else {
		side = RS;
		side_adj = AS;
		sign = -1.0;
	}

	/* set up the beginning coord */
	MALLOC(CRVLIST, curvelist_p, 1);
	curvelist_p->prev = (struct CRVLIST *) 0;
	if (is_phrase == YES) {
		/* Start slightly to east of center, so that if another
		 * curves ends on this group, they won't quite touch */
		curvelist_p->x = begin_gs_p->c[AX] + XOFFSET4CURVE;
		if (begin_gs_p->grpcont != GC_SPACE) {
			curvelist_p->y = begin_gs_p->c[side]
				+ eff_tupext(begin_gs_p, mll_p->u.staff_p, place)
				+ (sign * 2.0 * Stdpad);
			/* If there is something in [side_adj] there
			 * was another phrase on this group. But if that phrase
			 * ended on this group, it can be ignored. */
			if (begin_gs_p->c[side_adj] != 0.0 &&
					(begin_gs_p->phraseside & EAST_SIDE)) {
				curvelist_p->y += begin_gs_p->c[side_adj];
			}
		}
		else {
			/* bizarre case. first group is a space.
			 * Use 1 step from top or bottom of staff for y coord */
			curvelist_p->y = sign * (1 + halfstaffhi(begin_gs_p->staffno));
		}
	}

	else { /* is tie or slur */

		curvelist_p->y = begnote_p->c[RY];
		y_adj = 0.0;

		/* if on the "end" note of a group,
		 * the curve can probably be moved
		 * to the x of the note instead of the edge of the group.
		 * We assume it can if the curve bends away
		 * from the stem and there are no "with"
		 * list items on the group. If there is a with list, move
		 * a little bit, but not enough to hit with items */
		if (begin_gs_p->stemdir == UP && place == PL_BELOW
				&& begnote_p == &(begin_gs_p->notelist
				[begin_gs_p->nnotes - 1])) {
			if (begin_gs_p->nwith == 0 || begin_gs_p->normwith == NO) {
				curvelist_p->x = begnote_p->c[AX]
							+ (2.0 * Stdpad);
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				curvelist_p->y -= y_adj;
			}
			else {
				curvelist_p->x = begnote_p->c[AE];
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
				curvelist_p->y -= y_adj;
			}
		}
		else if (begin_gs_p->stemdir == DOWN && place == PL_ABOVE
				&& begnote_p == &(begin_gs_p->notelist[0])) {
			if (begin_gs_p->nwith == 0
						|| begin_gs_p->normwith == NO) {
				curvelist_p->x = begnote_p->c[AX]
					+ (2.0 * Stdpad);
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				curvelist_p->y += y_adj;
			}
			else {
				curvelist_p->x = begnote_p->c[AE];
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
				curvelist_p->y += y_adj;
			}
		}

		/* whole notes and longer don't really have a stem, so top
		 * note of "stem up" can be moved. Stemless grace notes also
		 * don't have a stem, so the same logic applies. */
		else if ( (begin_gs_p->basictime < 2
				|| (begin_gs_p->grpvalue == GV_ZERO
				&& begin_gs_p->basictime < 8))
				&& begin_gs_p->stemdir == UP
				&& place == PL_ABOVE &&
				begnote_p == &(begin_gs_p->notelist[0])) {
			if (begin_gs_p->nwith == 0
					|| begin_gs_p->normwith == YES) {
				curvelist_p->x = begnote_p->c[AX] + Stdpad;
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				curvelist_p->y += y_adj;
			}
			else {
				curvelist_p->x = begnote_p->c[AE];
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
				curvelist_p->y += y_adj;
			}
		}

		/* can also be moved if bottom note of stem-down group */
		else if (begin_gs_p->stemdir == DOWN && place == PL_BELOW
				&& begnote_p == &(begin_gs_p->notelist
				[begin_gs_p->nnotes - 1])  &&
				stuff_p->carryin == NO) {
			if (begin_gs_p->basictime < 2 && begin_gs_p->nwith > 0
					&& begin_gs_p->normwith == NO) {
				curvelist_p->x = begin_gs_p->c[AE];
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
				curvelist_p->y -= y_adj;
			}
			else {
				curvelist_p->x = begin_gs_p->c[AX];
				y_adj = (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				curvelist_p->y -= y_adj;
			}
		}
		else {
			curvelist_p->x = begin_gs_p->c[AX] +
					notehorz(begin_gs_p, begnote_p, RE) +
					Stdpad;
		}

		/* If two notes are a stepsize apart and the curve from the
		 * west note is bending towards the east note,
		 * then the x should be moved east a little.
		 * First case: this isn't the top note, but the note just
		 * above is 1 stepsize away and on the east side, and the
		 * curve is going up and it's not a carryin. */
		if (begnote_p != &(begin_gs_p->notelist[0]) &&
				begnote_p->stepsup ==
				begnote_p[-1].stepsup - 1 &&
				begnote_p->c[RX] < begnote_p[-1].c[RX] &&
				place == PL_ABOVE &&
				stuff_p->carryin == NO) {
			curvelist_p->x += 1.5 * Stepsize;
		}
		/* Second case: not bottom note, note just
		 * below is one step away and on the east side, the curve
		 * is going down, and it's not a carryin. */
		else if (begnote_p != &(begin_gs_p->notelist[begin_gs_p->nnotes-1]) &&
				begnote_p->stepsup ==
				begnote_p[1].stepsup + 1 &&
				begnote_p->c[RX] < begnote_p[1].c[RX] &&
				place == PL_BELOW &&
				stuff_p->carryin == NO) {
			curvelist_p->x += 1.5 * Stepsize;
		}
				
	}

	/* if carried over from previous score, start a bit farther left */
	if (stuff_p->carryin == YES) {

		/* find the pseudo bar and set x to that */
		for (bar_mll_p = mll_p->prev;
					bar_mll_p != (struct MAINLL *) 0;
					bar_mll_p = bar_mll_p->prev) {
			if (bar_mll_p->str == S_CLEFSIG) {
				if (bar_mll_p->u.clefsig_p->bar_p
							== (struct BAR *) 0) {
					/* carryin to an ending */
					continue;
				}
				curvelist_p->x =
					bar_mll_p->u.clefsig_p->bar_p->c[AE]
					- (TIESLURPAD * Staffscale);

				/* Long notes (wholes, etc) generally get
				 * more space on their left than short notes,
				 * so a curve carried in to a long note
				 * may look overly long, especially if other
				 * scores on the same page have carryins
				 * to short notes. So limit carryin curve
				 * length to 5 stepsizes.
				 */
				if (begin_gs_p->c[AW] - curvelist_p->x > 5.0 * Stepsize) {
					curvelist_p->x = begin_gs_p->c[AW]
							- 5.0 * Stepsize;
				}
				break;
			}
			else if (bar_mll_p->str == S_BAR) {
				/* carryin to an ending */
				curvelist_p->x = begin_gs_p->c[AW];
				break;
			}
		}

		if (bar_mll_p == (struct MAINLL *) 0) {
			pfatal("missing CELFSIG when carrying over %s mark",
								name);
		}
	}

	/* set up ending coord */
	MALLOC(CRVLIST, endlist_p, 1);
	if (is_phrase == YES) {
		/* End slightly to west of group center, so that another
		 * curve can start on this group (if needed) with
		 * touching this curve. */
		endlist_p->x = end_gs_p->c[AX] - XOFFSET4CURVE;
		if (end_gs_p->grpcont != GC_SPACE) {
			endlist_p->y = end_gs_p->c[side]
				+ eff_tupext(end_gs_p, mll_p->u.staff_p, place)
				+ (sign * 2.0 * Stdpad);
			/* Add in space for any relevant nested phrases */
			if (end_gs_p->c[side_adj] != 0.0 &&
					(end_gs_p->phraseside & WEST_SIDE)) {
				endlist_p->y += end_gs_p->c[side_adj];
			}
		}
		else {
			/* bizarre case. last group is a space.  Use 1 stepsize
			 * from top or bottom of staff for y coord */
			endlist_p->y = sign * (1 + halfstaffhi(begin_gs_p->staffno));
		}
	}
	else {
		if (stuff_p->carryin == YES) {
			/* in case of carryin, the "begin" group is actually
			 * the ending group, so set the end group, and
			 * adjust the beginning y */
			endlist_p->x = begin_gs_p->c[AW];

			/* adjust things carried into endings to account for
			 * the padding that was added */
			if (bar_mll_p->str == S_BAR) {
				endlist_p->x += TIESLURPAD * Staffscale;
			}

			endlist_p->y = curvelist_p->y;
			end_gs_p = begin_gs_p;

			/* if end note, adjust */
			if (place == PL_ABOVE && begnote_p
						== &(begin_gs_p->notelist[0])) {
				endlist_p->x = begnote_p->c[AX];
				if ((begin_gs_p->basictime > 1) &&
						(begin_gs_p->stemdir == UP)) {
					endlist_p->y += Stepsize;
					curvelist_p->y += Stepsize;
				}
			}
			else if (place == PL_BELOW && begnote_p ==
						&(begin_gs_p->notelist
						[begin_gs_p->nnotes - 1])
						&& (begin_gs_p->stemdir == UP
						|| begin_gs_p->basictime < 2)) {
				endlist_p->x = begnote_p->c[AX];
				if ((begin_gs_p->basictime < 2) &&
						(begin_gs_p->stemdir == DOWN)) {
					endlist_p->y -= Stepsize;
					curvelist_p->y -= Stepsize;
				}
			}
		}
		else {
			/* not carryin */
			end_gs_p = find_next_group (mll_p, begin_gs_p,
				(stuff_p->curveno == -1 ? "tie" : "slur"));
			if (stuff_p->curveno == -1) {
				/* this is a tie */
				endnote_p = find_matching_note (end_gs_p,
						begnote_p->letter,
						begnote_p->octave, "tie");
			}
			else {
				if (IS_NOWHERE(begnote_p->slurtolist
						[stuff_p->curveno].octave)) {
					pfatal("curve_points called on slide to nowhere");
				}

				endnote_p = find_matching_note (end_gs_p,
						begnote_p->slurtolist
						[stuff_p->curveno].letter,
						begnote_p->slurtolist
						[stuff_p->curveno].octave,
						"slur/slide");
			}

			endlist_p->y = endnote_p->c[RY];

			y2_adj = 0.0;

			/* move if below curve and bottom note with stem up */
			if (end_gs_p->stemdir == UP && place == PL_BELOW
					&& endnote_p == &(end_gs_p->notelist
					[end_gs_p->nnotes - 1])) {
				if (end_gs_p->nwith == 0
						|| end_gs_p->normwith == NO) {
					endlist_p->x = endnote_p->c[AX]
						- (2.0 * Stdpad);
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
					endlist_p->y -= y2_adj;
				}
				else {
					endlist_p->x = endnote_p->c[AW];
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
					endlist_p->y -= y2_adj;
				}
			}

			/* move if above and top note with stem down */
			else if (end_gs_p->stemdir == DOWN && place == PL_ABOVE
				     && endnote_p == &(end_gs_p->notelist[0])) {
				if (end_gs_p->nwith == 0
						|| end_gs_p->normwith == NO) {
					endlist_p->x = endnote_p->c[AX]
							- (2.0 * Stdpad);
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
					endlist_p->y += y2_adj;
				}
				else {
					endlist_p->x = endnote_p->c[AW];
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
					endlist_p->y += y2_adj;
				}
			}

			/* whole and longer don't have stem, so end note where
			 * a stem would be (if there were one) can be moved */
			else if (end_gs_p->basictime < 2 &&
					end_gs_p->stemdir == DOWN
					&& place == PL_BELOW
					&& endnote_p == &(end_gs_p->notelist
					[end_gs_p->nnotes - 1])) {
				if (end_gs_p->nwith == 0
						|| end_gs_p->normwith == YES) {
					endlist_p->x = endnote_p->c[AX]
								- Stdpad;
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
					endlist_p->y -= y2_adj;
				}
				else {
					endlist_p->x = endnote_p->c[AW];
					y2_adj = (Stepsize *
						(endnote_p->notesize
						== GS_NORMAL ? 1.2 : 0.9));
					endlist_p->y -= y2_adj;
				}
			}

			/* move if above and top note of stem up */
			else if (end_gs_p->stemdir == UP && place == PL_ABOVE
					&& endnote_p ==
					&(end_gs_p->notelist[0]) ) {
				endlist_p->x = end_gs_p->c[AX];
				y2_adj = (Stepsize * (endnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				endlist_p->y += y2_adj;

				/* if tied from note is also the top of its
				 * group, level the tie/slur */
				if (begin_gs_p->stemdir == UP &&
						begnote_p ==
						&(begin_gs_p->notelist[0])  &&
						begin_gs_p->basictime > 1 ) {
					curvelist_p->y += (Stepsize *
						(begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
				}
			}
			else if (begin_gs_p->grpvalue == GV_ZERO) {
				/* grace note to main note, can't use the west
				 * of the end group because that would include
				 * the grace note. */
				endlist_p->x = endnote_p->c[AX] +
					notehorz(end_gs_p, endnote_p, RW);
			}
			else {
				endlist_p->x = tieslurx(end_gs_p, endnote_p,
					stuff_p->place) - (2.0 * Stdpad);
			}

			/* if note tied from is bottom of group with stem down,
			 * level the tie/slur */
			if (end_gs_p->stemdir == DOWN && place == PL_BELOW
					&& endnote_p == &(end_gs_p->notelist
					[end_gs_p->nnotes - 1]) &&
					begin_gs_p->stemdir == DOWN &&
					begnote_p == &(begin_gs_p->notelist
					[begin_gs_p->nnotes - 1]) &&
					end_gs_p->basictime > 1 ) {
				endlist_p->y -= (Stepsize *
						(begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
			}

			/* if beginning of curve was adjusted and this is
			 * an inner note, but there is room on the relevant
			 * side, and this is a tie, then adjust this end's y
			 * to level the curve */
			else if (y_adj != 0.0 && stuff_p->curveno == -1) {
				endlist_p->y += inner_adj(end_gs_p, endnote_p,
							y_adj, place);
			}

			/* level beginning if the note in the previous
			 * chord was the same note but wasn't the top,
			 * but the next note is more than a stepsize
			 * away. */
			if (y2_adj != 0.0 && stuff_p->curveno == -1) {
				curvelist_p->y += inner_adj(begin_gs_p,
					begnote_p, y2_adj, place);
			}
		}
	}

	/* one final adjustment. If the stem of first group is up and stem
	 * of second group is down, and the notes being tied/slurred are both
	 * the tops notes if the place is above or both bottom notes if the
	 * place is below, then move the y coord on the side that wasn't
	 * already moved, to level the curve. Do only if the note is shorter
	 * than a whole note, because longer notes were already moved because
	 * they had no stem. */
	if (is_phrase == NO && begin_gs_p->stemdir == UP
					&& end_gs_p != (struct GRPSYL *) 0
					&& end_gs_p->stemdir == DOWN) {
		if (place == PL_ABOVE && begnote_p ==
				&(begin_gs_p->notelist[0])
				&& endnote_p == &(end_gs_p->notelist[0])
				&& begin_gs_p->basictime > 1) {
			curvelist_p->y += (Stepsize * (begnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
		}
		else if (place == PL_BELOW && begnote_p ==
				&(begin_gs_p->notelist[begin_gs_p->nnotes - 1])
				&& endnote_p ==
				&(end_gs_p->notelist[end_gs_p->nnotes - 1])
				&& end_gs_p->basictime > 1) {
			endlist_p->y -= (Stepsize * (endnote_p->notesize
						== GS_NORMAL ? 1.7 : 1.2));
		}
	}

	endlist_p->next = (struct CRVLIST *) 0;
	/* no need to set other links now because we will be added other nodes
	 * in between in a moment anyway */
	
	/* if carrying over, extend x to margin */
	if (stuff_p->carryout) {
		endlist_p->x = PGWIDTH - eff_rightmargin(mll_p);
	}

	/* find length of curve by Pythagorean */
	length = sqrt(SQUARED(endlist_p->x - curvelist_p->x)
				+ SQUARED(endlist_p->y - curvelist_p->y));

	/* Find y length for creating bulge in the curve.
	 * Make bigger bend if longer curve, but not too big or too small.
	 */
	ylen = length / 16;
	if (ylen > 2.2 * Stepsize) {
		ylen = 2.2 * Stepsize;
	}
	else if (ylen < (Stepsize * 0.75)) {
		ylen = Stepsize * 0.75;
	}
	ylen = ylen * sign;

	/* we figure out curve as if endpoints were on the x axis, then adjust
	 * with the proper sin and cos factors to get them where they really
	 * belong */
	sintheta = (endlist_p->y - curvelist_p->y) / length;
	costheta = (endlist_p->x - curvelist_p->x) / length;

	/* set up node for another point on curve */
	MALLOC(CRVLIST, new_p, 1);
	new_p->prev = curvelist_p;
	new_p->next = endlist_p;
	curvelist_p->next = new_p;
	endlist_p->prev = new_p;

	if (stuff_p->carryout == YES) {
		if (is_phrase == YES) {
			endlist_p->y += ylen / 2.0;
		}
		else {
			end_gs_p = begin_gs_p;
		}
	}

	/* First try a single point in the middle. Try bigger bulge
	 * value if some groups stick out, up to a maximum. */
	tb.mll_p = mll_p;
	tb.begin_gs_p = begin_gs_p;
	tb.end_gs_p = end_gs_p;
	tb.place = place;
	tb.curvelist_p = curvelist_p;
	tb.endlist_p = endlist_p;
	tb.xlen = length / 2.0;
	tb.ylen = ylen;
	tb.sintheta = sintheta;
	tb.costheta = costheta;
	tb.minbulge = MINBULGE;
	tb.maxbulge = MAXBULGE;
	try_p = &tb;
	if ((bulgeval = try_bulge(try_p)) < MAXBULGE) {
		/* This curve works. Go with it */
		if (bulgeval == MINBULGE) {
			/* The very first try worked with nothing in the way,
			 * so may be safe to try to
			 * beautify any really steep curves.
			 * So try to redo and see if still okay.
			 * If not, put back the original.
			 */
			double save_x, save_y;
			save_x = curvelist_p->next->x;
			save_y = curvelist_p->next->y;
			redo_steep(curvelist_p, endlist_p, place);
			if (stick_out(try_p) > 0.0) {
				curvelist_p->next->x = save_x;
		 		curvelist_p->next->y = save_y;
			}
		}
		/* adjust group boundaries to include the curve */
		final_touches(mll_p, begin_gs_p, end_gs_p, curvelist_p, place);

		/* attach the curve to the stuff */
		stuff_p->crvlist_p = curvelist_p;
		return;
	}

	/* Using a single inner point didn't give a good curve.
	 * So we'll try two inner points. Add another point to the curve. */
	MALLOC(CRVLIST, new_p, 1);
	new_p->prev = endlist_p->prev;
	new_p->next = endlist_p;
	new_p->prev->next = new_p;
	endlist_p->prev = new_p;

	/* We now have three segments, each 1/3 of total length */
	tb.xlen = length / 3.0;

	/* We're a little more desperate, so allow more bulge */
	tb.minbulge = MIN2BULGE;
	tb.maxbulge = MAX2BULGE;

	if ((bulgeval = try_bulge(try_p)) < MAXBULGE) {
		/* This curve works. Go with it */
		final_touches(mll_p, begin_gs_p, end_gs_p, curvelist_p, place);

		/* attach the curve to the stuff */
		stuff_p->crvlist_p = curvelist_p;
		return;
	}

	/* Really getting desperate now, so allow even more bulge */
	tb.minbulge = MIN3BULGE;
	tb.maxbulge = MAX3BULGE;

	/* Just adjusting bulge didn't work,
	 * so we try repeatedly moving the ends slightly
	 * and trying again until something works.
	 * Worst case should be something like an above curve encompassing c0
	 * to b9 back to c0, with a stem up on the b9. That would be about 80
	 * stepsizes. But if an end is a cross-staff stem group completely
	 * on the other staff, and if that other staff is ridiculously
	 * far away because of very tall STUFF, even 100 iterations
	 * of moving by a Stepsize sometimes isn't enough.
	 * So we'll try 200 times before giving up with a pfatal.
	 */
	found_good = NO;
	for (try = 0; try < 200; try++) {
		double mvbegin, mvend, mvboth;
		int leftcount, rightcount;

		/* Try moving each end individually and both together,
		 * then try to  go with whatever gave the best results
		 * with the least movement.
		 */

		/* try with just begin point moved */
		curvelist_p->y += Stepsize * sign;
		mvbegin = try_bulge(try_p);

		/* try with both endpoints moved */
		endlist_p->y += Stepsize * sign;
		mvboth = try_bulge(try_p);
		leftcount = tb.leftcount;
		rightcount = tb.rightcount;

		/* try with just end point moved */
		curvelist_p->y -= Stepsize * sign;
		mvend = try_bulge(try_p);

		/* See which of the three attempts seemed best */
		if ( (mvend < mvbegin && mvend < mvboth)
				|| (try < 5 && leftcount == 0 && rightcount > 0) ) {
			/* moving just the end was best */
			if (mvend < MAX3BULGE) {
				found_good = YES;
				break;
			}
		}
		else if ( (mvbegin < mvend && mvbegin < mvboth)
				|| (try < 5 && leftcount > 0 && rightcount == 0) ) {
			/* moving just the beginning was best */
			curvelist_p->y += Stepsize * sign;
			endlist_p->y -=  Stepsize * sign;
			if (mvbegin < MAX3BULGE) {
				found_good = YES;
				break;
			}
		}
		else {
			/* move both ends */
			curvelist_p->y += Stepsize * sign;
			if (mvboth < MAX3BULGE) {
				found_good = YES;
				break;
			}
		}
	}

	if (found_good == YES) {
		/* Call try_bulge again to set the inner points (the one
		 * we chose might not be the last one we tried. */
		(void) try_bulge(try_p);
		final_touches(mll_p, begin_gs_p, end_gs_p, curvelist_p, place);

		/* attach the curve to the stuff */
		stuff_p->crvlist_p = curvelist_p;
		return;
	}

	pfatal("unable to find a usable curve");
}
\f

/* 
 * Returns the smallest bulge factor that worked, or a value >= maxbulge if
 * nothing worked. The more the return value exceeds maxbulge, the worse
 * the amount of "stick out." The curvelist_p should point to a curve with
 * 3 or 4 points.
 */

static double
try_bulge(info_p)

struct TRYBULGE *info_p;	/* points to all the info this func needs */

{
	struct CRVLIST *mid_p;		/* interior point of curve */
	struct CRVLIST *mid2_p;		/* second inner point, if any */
	double bulge_factor;		/* how much to bulge */
	double amount = 0.0;		/* amount of stick out */


	/* Get pointer to the midpoint(s) */
	mid_p = info_p->curvelist_p->next;
	if (mid_p->next != info_p->endlist_p) {
		mid2_p = mid_p->next;
	}
	else {
		mid2_p = 0;
	}

	/* Keep trying bigger bulge until we find one that clears all the
	 * groups or until the specified maximum is reached. */
	for (bulge_factor = info_p->minbulge; bulge_factor < info_p->maxbulge;
						bulge_factor += 0.25) {

		/* find (x,y) values for midpoint(s) taking the rotation
		 * from horizontal into account. */
		mid_p->x = info_p->curvelist_p->x
			+ (info_p->xlen * info_p->costheta)
			- (bulge_factor * info_p->ylen * info_p->sintheta);
		mid_p->y = info_p->curvelist_p->y
			+ (bulge_factor * info_p->ylen * info_p->costheta)
			+ (info_p->xlen * info_p->sintheta);

		if (mid2_p != 0) {
			mid2_p->x = info_p->curvelist_p->x
				+ (2.0 * info_p->xlen * info_p->costheta)
				- (bulge_factor * info_p->ylen * info_p->sintheta);
			mid2_p->y = info_p->curvelist_p->y
				+ (bulge_factor * info_p->ylen * info_p->costheta)
				+ (2.0 * info_p->xlen * info_p->sintheta);
		}

		if ((amount = stick_out(info_p)) <= 0.0) {
			/* This curve works. Go with it */
			break;
		}
	}

	/* Even max allowed bulge value was not enough. Returning the max bulge
	 * allowed tells caller we failed, and adding on how much
	 * "stick-out" gives an indication of how badly we failed.
	 */
	return(bulge_factor + amount);
}
\f

/* adjust the endpoint of an inner note if the opposite end was adjusted,
 * and there is room to adjust this end. */

static double
inner_adj(gs_p, note_p, y_adj, place)

struct GRPSYL *gs_p;	/* not is in this group */
struct NOTE *note_p;	/* this is the note being tied to */
double y_adj;		/* how much other end of tie was adjusted */
int place;		/* PL_ABOVE or PL_BELOW */

{
	int i;


	if (gs_p->nnotes <= 2) {
		/* can't possibly be an inner note, so no adjust */
		return(0.0);
	}

	/* find index of note */
	for (i = 0; i < gs_p->nnotes; i++) {
		if (note_p == &(gs_p->notelist[i])) {
			break;
		}
	}

	if (i == gs_p->nnotes) {
		pfatal("couldn't find note in chord");
	}

	if (i == 0 || i == gs_p->nnotes - 1) {
		/* not an inner note. no adjust */
		return(0.0);
	}

	/* check if next note in chord is within STEPSIZE away. If not,
	 * we can adjust this end */
	if (place == PL_ABOVE && gs_p->notelist[i-1].stepsup
					> gs_p->notelist[i].stepsup + 1) {
		return(y_adj);
	}
	else if (place == PL_BELOW && gs_p->notelist[i+1].stepsup
					< gs_p->notelist[i].stepsup - 1) {
		/* y_adj will always come in as a positive number and will be
		 * added on return, so return negative value for below curves */
		return(-y_adj);
	}
	return(0.0);
}
\f

/* Returns the sum of the "stick out" of groups in the given curve.
 * If all groups are inside, this will be 0.0
 * Also counts number of "stickouts" that are near each end,
 * in case that might be useful in deciding which endpoint to move.
 * These counts are stored in the leftcount and rightcount fields of
 * the passed-in struct.
 */

static double
stick_out(info_p)

struct TRYBULGE *info_p;

{
	struct GRPSYL *gs_p;	/* to walk through list */
	struct GRPSYL *begin_gs_p, *end_gs_p;
	double yleft, yright;	/* y value of point on the line that is
				 * at the x position of the left and right
				 * sides of the current GRPSYL, */
	double yg;		/* y of group accounting for other phrases */
	struct MAINLL *mll_p;	/* the curve's STUFF hangs off of here */
	int place;		/* PL_* */
	struct CRVLIST *curvelist_p;	/* beginning of curve to check */
	struct CRVLIST *endlist_p;	/* end of curve to check */
	int staff;
	int voice;
	double stickout;	/* return value */
	double len;		/* length that is deemed "near the end" of the
				 * curve, for setting left/right counts */


	begin_gs_p = info_p->begin_gs_p;
	end_gs_p = info_p->end_gs_p;
	if (begin_gs_p == 0 || end_gs_p == 0) {
		pfatal("got null pointer when checking phrase marks");
	}

	info_p->leftcount = 0;
	info_p->rightcount = 0;

	/* If starting phrase on last note of score or ending one on first
	 * note of a score, begin and end will be the same. We know that
	 * note has already been accounted for, so nothing to do. */
	if (begin_gs_p == end_gs_p) {
		return(0.0);
	}

	staff = begin_gs_p->staffno;
	voice = begin_gs_p->vno;
	curvelist_p = info_p->curvelist_p;
	endlist_p = info_p->endlist_p;
	mll_p = info_p->mll_p;
	place = info_p->place;
	stickout = 0.0;
	/* We will be counting up how many groups stick out near each end,
	 * to potentially help decide which endpoint to move to avoid
	 * collisions. For that purpose, we'll define "near the end"
	 * as being within 1/4 of the total x distance from an endpoint.
	 */
	len = (endlist_p->x - curvelist_p->x) / 4.0;

	/* Go through each group between the beginning and end. We've
	 * already set the curve endings to clear the group boundaries */
	for (gs_p = begin_gs_p->next; gs_p != end_gs_p; gs_p = gs_p->next) {

		/* If hit end of measure go to next measure */
		if (gs_p == (struct GRPSYL *) 0) {
			mll_p = next_staff(staff, mll_p->next);
			if (info_p->mll_p == (struct MAINLL *) 0) {
				pfatal("fell off end of list while doing phrase marks");
			}
			gs_p = mll_p->u.staff_p->groups_p[voice - 1];
		}

		if (gs_p == end_gs_p) {
			break;
		}

		/* Find out where the y of the curve is at this group.
		 * We actually check two points, one each slightly
		 * to the east and west of the group's x.
		 * It would even more accurate to figure out the actual
		 * width of whatever is at the end (a notehead, a stem,
		 * a rest, stem with flag, etc) but just taking 1.5 Stepsizes
		 * on either side generally gives adequate results and
		 * is a lot simpler.
		 */
		yleft = curve_y_at_x(curvelist_p, gs_p->c[AX] - 1.5 * Stepsize);
		yright = curve_y_at_x(curvelist_p, gs_p->c[AX] + 1.5 * Stepsize);

		/* See if this group is within the curve */
		if (info_p->place == PL_ABOVE) {
			/* Consider the group (RN) plus any relevant
			 * nested phrase marks (their space is stored in AN).
			 * It is relevant unless it's for the begin group
			 * and that group's east is not relevent, or it's the
			 * end group and that group's west is not relevant */
			yg = gs_p->c[RN] + CLEARANCE
				+ eff_tupext(gs_p, mll_p->u.staff_p, place);
			if ( (gs_p != begin_gs_p ||
					((gs_p->phraseside & EAST_SIDE) == 0))
					&& (gs_p != end_gs_p ||
					((gs_p->phraseside & WEST_SIDE) == 0)) ) {
				yg += gs_p->c[AN];
			}
			if (yleft > yg && yright > yg) {
				/* Good. It's inside */
				continue;
			}
			else {
				/* Bad. It stuck over */
				stickout += yg - MIN(yleft, yright);
				/* If near either end, make a note of that */
				if (gs_p->c[AX] - curvelist_p->x < len) {
					info_p->leftcount += 1;
				}
				else if (endlist_p->x - gs_p->c[AX] < len) {
					info_p->rightcount +=1;
				}
			}
		}
		else {
			/* Do the same for curve going down */
			yg = gs_p->c[RS] - CLEARANCE
				+ eff_tupext(gs_p, mll_p->u.staff_p, place);
			if ( (gs_p != begin_gs_p ||
					((gs_p->phraseside & EAST_SIDE) == 0))
					&& (gs_p != end_gs_p ||
					((gs_p->phraseside & WEST_SIDE) == 0)) ) {
				yg += gs_p->c[AS];
			}
			if (yleft < yg && yright < yg) {
				continue;
			}
			else {
				stickout += MAX(yleft, yright) - yg;
				if (gs_p->c[AX] - curvelist_p->x < len) {
					info_p->leftcount++;
				}
				else if (endlist_p->x - gs_p->c[AX] < len) {
					info_p->rightcount++;
				}
			}
		}
	}
	return(stickout);
}
\f

/* find the x of the end of a tie/slur. Usually we could just used the west of
 * the group, but if there are lots of accidentals on notes that are far
 * away from the note in question, the end of the tie can come out rather
 * far away from its note. So try to see if we can move it closer, by
 * checking to see if there are any accidentals on notes nearby. This
 * function is not foolproof, sometimes leaving space when the tie/slur
 * could actually get threaded through a tiny opening, and sometimes
 * overwriting the edge of an accidental somewhat, but tries to do a better
 * job than the original single line of code for figuring this out had done. */

static double
tieslurx(gs_p, note_p, place)

struct GRPSYL *gs_p;	/* check notes in this group */
struct NOTE *note_p;	/* check for accidentals near this note */
int place;		/* PL_ABOVE or PL_BELOW to tell which side to look on */

{
	int n;		/* index through notelist */
	int acc;	/* accidental */


	/* if "wrong" side of a stem up group, better use group boundary */
	if (note_p->c[AX] > gs_p->c[AX] && gs_p->stemdir == UP) {
		return(gs_p->c[AW]);
	}

	/* if there is another note nearby,
	 * and that note has an accidental, better use
	 * the west of the group to be safe, otherwise
	 * use the west of the note. */
	for (n = 0; n < gs_p->nnotes; n++) {

		acc = gs_p->notelist[n].accidental;
		switch (gs_p->notelist[n].stepsup - note_p->stepsup) {
		case 1:
		case 2:
			/* close enough that sharp, flat, and dblflat may
			 * interfere, if coming in from above */
			if (place == PL_ABOVE && (acc == '#' || acc == '&'
							|| acc == 'B')) {
				return(gs_p->c[AW]);
			}
			break;
		case 3:
			/* close enough that sharp may interfere, if coming
			 * in from above */
			if (place == PL_ABOVE && acc == '#') {
				return(gs_p->c[AW]);
			}
			break;
		case 0:
			/* the note itself */
			break;
		case -1:
			/* sharp, flat, and dblflat may interfere from
			 * either direction */
			if (acc == '#' || acc == '&' || acc == 'B') {
				return(gs_p->c[AW]);
			}
			break;

		case -2:
		case -3:
		case -4:
			/* close enough that things may interfere */
			if (place == PL_BELOW && (acc == '#' || acc == '&'
							|| acc == 'B')) {
				return(gs_p->c[AW]);
			}
			break;

		default:
			/* this note is too far away to matter */
			break;
		}
	}

	/* it seems there are no accidentals in the way, so use the note
	 * boundary, rather than group boundary */
	return(gs_p->c[AX] + notehorz(gs_p, note_p, AW));
}
\f

/* given a main list struct, search forward from there for the STAFF matching
 * the given staff. If fall off end of main list, return NULL */

static struct MAINLL *
next_staff(staff, mll_p)

int staff;		/* find this staff number */
struct MAINLL *mll_p;	/* where to start */

{
	/* walk through main list looking for desired staff */
	for (  ; mll_p != (struct MAINLL *) 0; mll_p = mll_p->next) {
		if (mll_p->str == S_STAFF) {
			if (mll_p->u.staff_p->staffno == staff) {
				return(mll_p);
			}
		}
	}

	/* didn't find it */
	return( (struct MAINLL *) 0);
}
\f
/*
 * Name:	redo_steep()
 *
 * Abstract:	Redo curves that are very steep.
 *
 * Returns:	void
 *
 * Description:	If the curve is "too steep", it redoes it
 *		so that it's horizontal at the outer end, rather than already
 *		sloping in towards the inner end.
 *		Caller needs to verify the redone curve doesn't collide
 *		with any groups. Assumes the curve contains 3 points.
 */

static void
redo_steep (first_p, last_p, place)

struct CRVLIST *first_p;	/* left endpoint of curve */
struct CRVLIST *last_p;		/* right endpoint of curve */
int place;			/* above or below */

{
	struct CRVLIST *mid_p;		/* new midpoint of curve */
	float delx;			/* distance from the end to test */
	float a, b;			/* some distances, see below */
	float midoff;			/* vert offset of midpoint */


	/*
	 * We need to test whether either end of the curve is sloping in.  So
	 * we really should find the derivative at the endpoints.  But we can
	 * approximate it close enough by finding the y value at a point "near"
	 * the end and comparing it to the end's y value.  "delx" tells how
	 * near.  We'd like to set it to a millionth of an inch, but due to
	 * apparent roundoff errors in curve_y_at_x(), we make it bigger than
	 * that: 1/4 the curve length, but never more than 2 stepsizes.
	 */
	if (last_p->x - first_p->x > 8 * Stepsize) {
		delx = 2 * Stepsize;
	} else {
		delx = (last_p->x - first_p->x) / 4.0;
	}
	if (place == PL_ABOVE) {
		/* if both near points are higher than end points, return */
		if (curve_y_at_x(first_p, first_p->x + delx) >= first_p->y &&
		    curve_y_at_x(first_p, last_p->x  - delx) >= last_p->y) {
			return;
		}
	} else {
		/* if both near points are lower than end points, return */
		if (curve_y_at_x(first_p, first_p->x + delx) <= first_p->y &&
		    curve_y_at_x(first_p, last_p->x  - delx) <= last_p->y) {
			return;
		}
	}

	/*
	 * The curve is steep.  First, we choose a new point,
	 * horizontally in the middle.  We are
	 * going to choose its vertical position so that the outer end of the
	 * curve starts out horizontal.
	 *
	 * Imagine the case of PL_BELOW where the left end is the outer (lower)
	 * end.  (The other 3 cases are symmetrical to this, and we can use the
	 * analogous result.)  Set the axes so that the left end is at the
	 * origin, and the right end is at (2*a, b).  The new point will be at
	 * (a, y), and we have to find y.  We know that y will be between 0 and
	 * b/2.  (Draw a picture.)
	 *
	 * Draw segments from (0, 0) to (a, y), and (a, y) to (2*a, b).  Then
	 * draw a line through (a, y) such that it forms the same angle theta
	 * with each of these segments.  The way calccurve() works, it will
	 * form two cubic arcs (in rotated coordinate systems) through the
	 * three points, such that the slope of each arc at each point forms
	 * the same angle theta with the segment next to it.  The last line we
	 * drew hits the X axis at a point which, with (0, 0) and (a, y) forms
	 * an isoceles triangle, where the angles at (0, 0) and (a, y) are
	 * both theta (because we're saying the arc at (0, 0) is horizontal).
	 * So the other angle is 180 degrees minus 2*theta.  That means the
	 * other angle the line forms with the X axis is 2*theta.  And that
	 * means the angle between the horizontal line through (a, y) and the
	 * second segment (a, y) to (2*a, b) is 3*theta.
	 *
	 * Looking at triangle (0, 0) to (a, 0) to (a, y), we see that
	 *	tan(theta) = y/a
	 * Looking at triangle (a, y) to (2*a, y) to (2*a, b), we see that
	 *	tan(3*theta) = (b-y)/a
	 * There is a trig identity
	 * 			3*tan(theta) - (tan(theta))^3
	 *	tan(3*theta) =	------------------------------
	 *				1 - 3*(tan(theta))^2
	 * Plug into this our values for tan(theta) and tan(3*theta), and you
	 * end up with
	 *	4 y^3 - 3 b y^2 - 4 a^2 y + a^2 b = 0
	 * To solve this cubic, we could do a whole routine for solving cubics,
	 * but it's easier to approximate as follows.
	 *
	 # Define
	 *	F(x) = 4 x^3 - 3 b x^2 - 4 a^2 x + a^2 b
	 * a and b are positive.  So at x = 0, F(x) > 0.  At x=b/2, F(x) < 0.
	 * Thus, as we expect, F(x) = 0 somewhere in between.  For the
	 * following algorithm to work, we need to know that F(x) is strictly
	 * decreasing (the slope is always negative).  The slope is
	 *	F'(x) = 12 x^2 - 6 b x - 4 a^2
	 * (the derivative).  It is a parabola opening upward and going through
	 * (0, -4a^2) and (b/2, -4a^2).  So it is always negative in this
	 * interval.
	 *
	 * The algorithm starts with lo = 0 and hi = b/2.  It draws a straight
	 * line between (lo, F(lo)) and (hi, F(hi)).  The point where this
	 * crosses the X axis we call "mid".  Based on whether F(mid) is
	 * positive or negative, we reset lo or hi to mid, and repeat the
	 * process until F(mid) is within b/1000 of the axis.  Then we will use
	 * mid as our y value in the picture.
	 */
	a = ABSDIFF(first_p->x, last_p->x) / 2.0;
	b = ABSDIFF(first_p->y, last_p->y);

	midoff= solvecubic(4.0, -3.0*b, -4.0*a*a, a*a*b, 0.0, b/2.0, POINT/2.0);

	mid_p = first_p->next;
	mid_p->x = first_p->x + a;	/* horizontally halfway between */

	/* handle the 4 cases, using the "mid" value for y in the diagram */
	if (place == PL_ABOVE) {
		if (first_p->y < last_p->y) {
			mid_p->y = last_p->y - midoff;
		} else {
			mid_p->y = first_p->y - midoff;
		}
	} else {
		if (first_p->y < last_p->y) {
			mid_p->y = first_p->y + midoff;
		} else {
			mid_p->y = last_p->y + midoff;
		}
	}
}
\f

/* do final refinements of curve.
 * Remove any really tiny line segments.
 * Then reset the group north or south boundaries to reflect
 * the inclusion of the phrase mark.
 */

static void
final_touches(mll_p, begin_gs_p, end_gs_p, curvelist_p, place)

struct MAINLL *mll_p;			/* points to first group in curve */
struct GRPSYL *begin_gs_p;		/* first group in curve */
struct GRPSYL *end_gs_p;		/* last group in curve */
struct CRVLIST *curvelist_p;		/* the curve */
int place;				/* PL_ABOVE or PL_BELOW */

{
	int voice;	
	int staff;
	int index;	/* in coord array: RN or RS */
	int adj_index;	/* in coord array: AN or AS. Used to store how much
			 * to adjust for this phrase, in case there are
			 * nested phrases. */
	float y_c;	/* y of curve */
	float x1, y1;	/* lengths of segments in each dimension */
	float length;	/* of line segment */
	struct CRVLIST *crvlist_p;
	struct CRVLIST *extra_p;	/* pointer to point to be freed */
	struct GRPSYL *gs_p;	/* index through groups */


	if ( (mll_p == (struct MAINLL *) 0)
			|| (begin_gs_p == (struct GRPSYL *) 0)
			|| (end_gs_p == (struct GRPSYL *) 0)
			|| (curvelist_p == (struct CRVLIST *) 0) ) {
		pfatal("null pointer in final_touches()");
	}

	/* If there are really tiny line segments in a curve, the code for
	 * tapering the curve has problems because if the width of the curve
	 * is more than the length of the line and the angles work out just
	 * wrong, various warts, sometimes huge ones, appear on the curves.
	 * So go through the curve and if there are any really tiny lines,
	 * throw away one of the points and make the remaining point the
	 * average of what it was and what the discarded one was.
	 * With the new way of calculating curves, this is probably now
	 * unnecessary, but it seems safer to leave it in, just in case.
	 */
	for (crvlist_p = curvelist_p; crvlist_p->next != (struct CRVLIST *) 0;
						crvlist_p = crvlist_p->next) {
		x1 = crvlist_p->next->x - crvlist_p->x;
		y1 = crvlist_p->next->y - crvlist_p->y;
		length = sqrt(SQUARED(x1) + SQUARED(y1));
		if (length < 0.01) {
			/* replace with average */
			crvlist_p->x = (crvlist_p->x + crvlist_p->next->x)
								/ 2.0;
			crvlist_p->y = (crvlist_p->y + crvlist_p->next->y)
								/ 2.0;
			/* take the extra out of the list */
			extra_p = crvlist_p->next;
			if (crvlist_p->next->next != (struct CRVLIST *) 0) {
				crvlist_p->next->next->prev = crvlist_p;
			}
			crvlist_p->next = crvlist_p->next->next;
			if (crvlist_p->next == (struct CRVLIST *) 0) {
				/* avoid trying to take ->next of null ptr */
				break;
			}
			FREE(extra_p);
		}
	}

	/* adjust north or south of each group within the curve to account for
	 * the space needed for the curve */
	voice = begin_gs_p->vno;
	staff = begin_gs_p->staffno;
	if (place == PL_ABOVE) {
		index = RN;
		adj_index = AN;
	}
	else {
		index = RS;
		adj_index = AS;
	}

	for (gs_p = begin_gs_p;     ; gs_p = gs_p->next) {

		/* if hit end of measure go to next measure, skipping over
		 * any empty measure (which could happen if vscheme changed
		 * from 2 to 1 and back in the middle of the phrase) */
		while (gs_p == (struct GRPSYL *) 0) {
			mll_p = next_staff(staff, mll_p->next);
			if (mll_p == (struct MAINLL *) 0) {
				pfatal("fell off end of list while doing phrase marks");
			}
			gs_p = mll_p->u.staff_p->groups_p[voice - 1];
		}

		/* find where the curve y is at the x of the group, and
		 * adjust the north or south of the group appropriately,
		 * to be used later by any nesting phrase marks */
		y_c = curve_y_at_x(curvelist_p, gs_p->c[AX]);

		/* check for an inner tie. They don't affect the boundary */
		if ( ((index == RN) && (y_c < gs_p->c[index])) ||
				((index == RS) && (y_c > gs_p->c[index]))) {
			gs_p->c[adj_index] = 0.0;
		}
		else {
			if (place == PL_ABOVE) {
				gs_p->c[adj_index] = (y_c - gs_p->c[index]
								+ Stepsize);
			}
			else {
				gs_p->c[adj_index] =  - (gs_p->c[index] - y_c
								+ Stepsize);
			}
		}

		if (gs_p == end_gs_p) {
			/* On the last group on the phrase, this phrase
			 * only affects the west side--another phrase can
			 * start on this same group with considering this one */
			gs_p->phraseside |= WEST_SIDE;
			/* We are done with this curve */
			break;
		}
		else if (gs_p == begin_gs_p){
			/* Only affects east side of first group */
			gs_p->phraseside |= EAST_SIDE;
		}
		else {
			/* not of the end, so both side are relevant */
			gs_p->phraseside |= (EAST_SIDE | WEST_SIDE);
		}
	}
}
\f

/* determine effective tuplet extension value. Normally, the tupext tells
 * us how much room to leave to allow for the tuplet bracket. However,
 * if the tuplet doesn't get a bracket, this can cause us to leave extra
 * space. Unfortunately, we do still need to leave room for the tuplet
 * number even if the bracket isn't there, and it's hard to know exactly
 * where the number is going to be. So we do the best we can: if the
 * group is the start or end of a tuplet and the tuplet does not get a
 * bracket, we ignore the tupext on that group. If it's in the middle
 * of a tuplet, we leave the tupext as is, because we can't tell for sure
 * whether we'll need it to get out of the way of the tuplet number or not.
 * But if this isn't a tuplet, or its bracket is on the opposite side
 * as where we're trying to put a curve, then it doesn't count as all.
 */

static double
eff_tupext(gs_p, staff_p, side)

struct GRPSYL *gs_p;
struct STAFF *staff_p;
int side;		/* where the curve will be */

{
	/* if not a tuplet, return tupextend as is */
	if (gs_p->tuploc == NOITEM) {
		return(gs_p->tupextend);
	}

	/* if curve is on opposite side as tuplet bracket, ignore tupextend */
	if (side != tupdir(gs_p, staff_p)) {
		return(0.0);
	}
	/* if group passed in is first group in a tuplet,
	 * but the tuplet gets no bracket, ignore the tupextend */
	if (gs_p->tuploc == STARTITEM) {
		if (tupgetsbrack(gs_p) == NO) {
			return(0.0);
		}
	}

	/* if group passed in is last group in a tuplet,
	 * but the tuplet gets no bracket, ignore the tupextend */
	if (gs_p->tuploc == ENDITEM) {
		/* first have to back up to find first group of tuplet,
		 * because that's what tupgetsbrack() wants */
		do {
			gs_p = gs_p->prev;
			if (gs_p == (struct GRPSYL *) 0) {
				pfatal("can't find tuplet start in eff_tupext");
			}
		} while (gs_p->tuploc != STARTITEM);

		if (tupgetsbrack(gs_p) == NO) {
			return(0.0);
		}
	}

	/* if no special case applies, just return tupextend as is */
	return(gs_p->tupextend);
}
\f

/* determine correct bend direction for curve, return UP or DOWN */

static int
bulge_direction(mll_p, gs1_p, note_index, curveno)

struct MAINLL *mll_p;	/* main list struct pointing to gs1_p */
struct GRPSYL *gs1_p;	/* curve will be from note in gs1_p to note in gs2_p */
int note_index;		/* which note in first group to tie */
int curveno;		/* index into slurto, or -1 for a tie */

{
	struct GRPSYL *gs_p;
	RATIONAL vtime1, vtime2;	/* beginning and ending time of group */
	int othervoice;			/* array index of other voice */


	/* If user explicitly set a bend direction, use that */
	if (curveno == -1 && gs1_p->notelist[note_index].tiedir != UNKNOWN) {
		return(gs1_p->notelist[note_index].tiedir);
	}
	else if (curveno >= 0 && gs1_p->notelist[note_index]
				.slurtolist[curveno].slurdir != UNKNOWN) {
		return(gs1_p->notelist[note_index].slurtolist[curveno].slurdir);
	}

	/* If there are 2 voices on the staff, bend is toward the stem */
	/* However, if the other voice is all spaces, pretend there is only
	 * one voice */
	if ( (mll_p->u.staff_p->groups_p[0] != (struct GRPSYL *) 0)
				&& (mll_p->u.staff_p->groups_p[1]
				!= (struct GRPSYL *) 0) ) {

		/* there are 2 voices */

		/* calculate begin and end time of tied group */
		vtime1 = Zero;
		for (gs_p = mll_p->u.staff_p->groups_p[gs1_p->vno - 1];
					gs_p != gs1_p; gs_p = gs_p->next) {
			vtime1 = radd(vtime1, gs_p->fulltime);
		}

		/* ending time is vtime1 plus the length of group 1. If group
		 * 1 is a grace note, use a very short time */
		if (EQ(gs1_p->fulltime, Zero)) {
			RATIONAL tiny;

			tiny.n = 1;
			tiny.d = 4 * MAXBASICTIME;
			vtime2 = radd(vtime1, tiny);
		}
		else {
			vtime2 = radd(vtime1, gs1_p->fulltime);
		}

		/* get array index of other voice to check it */
		othervoice = (gs1_p->vno == 1 ? 1 : 0);

		if (hasspace(mll_p->u.staff_p->groups_p[othervoice],
					vtime1, vtime2) == NO) {
			/* there IS another voice, so stem goes opposite */
			return(gs1_p->stemdir);
		}
	}

	/* if only one voice (either because there is actually only one
	 * or because there is effectively only one since the other is space)
	 * and there is only one note in group, then bend is opposite stem */
	if (gs1_p->nnotes < 2) {
		/* quarter note grace groups are a special case, since they
		 * don't have a stem (they are for showing prebends). So we
		 * put the bend opposite the stem of the following group. */
		if (gs1_p->grpvalue == GV_ZERO && gs1_p->basictime == 4 &&
				gs1_p->next != (struct GRPSYL *) 0) {
			return(gs1_p->next->stemdir == UP ? DOWN : UP);
		}
		return(gs1_p->stemdir == UP ? DOWN : UP);
	}
	
	/* if one voice on staff with more than one note in the group, all
	 * bend opposite the stem except the top if the stem is up or the
	 * bottom if the stem is down */
	if ( ((gs1_p->stemdir == DOWN) && (note_index == gs1_p->nnotes - 1))
			|| ((gs1_p->stemdir == UP) && (note_index == 0)) ) {
		return(gs1_p->stemdir);
	}
	else {
		return(gs1_p->stemdir == UP ? DOWN : UP);
	}
}