Merge branch 'arkkra' into shiny

[mup] / mup / mup / utils.c

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

/* miscellaneous utility functions for music publication program, mostly
 * for the print phase */

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

static void grp_octave_adjust P((struct GRPSYL *gs_p, int adj, struct MAINLL *mll_p));
static void set_height_blockhead P((struct BLOCKHEAD *blockhead_p, int context,
		struct MAINLL *mll_p));
static double coord_staffscale P((float *coord_array));

\f

/* set _cur location variable to specified value */

void
set_cur(x, y)

float x, y;	/* x, east, and west get set to x value. y, north and south,
		 * get set to y value */

{
	float *cur_p;	/* coord array for _cur in current context */


	/* look up _cur symbol and fill in the values */
	cur_p = symval("_cur", (float **) 0);
	cur_p[AX] = cur_p[AE] = cur_p[AW] = x;
	cur_p[AY] = cur_p[AN] = cur_p[AS] = y;
}
\f

/* set the values for location variable _win */

void
set_win(n, s, e, w)

float n, s, e, w;	/* north, south, east, and west */

{
	float *window;	/* coordinate info for _win */


	/* look up symbol and fill in values */
	window = symval("_win", (float **) 0);
	window[AN] = n;
	window[AS] = s;
	window[AE] = e;
	window[AW] = w;
	/* set x and y to midpoints of rectangle */
	window[AY] = s + (n - s)/2.0;
	window[AX] = w + (e - w)/2.0;
}
\f

/* Return width of a bar line. Allow a couple pixels on either side
 * of the actual line(s) [and dots]. Does not include user padding.
 * Since an invisbar has no lines or dots, it has zero width.
 */

double
width_barline(bar_p)

struct BAR *bar_p;	/* return width of this bar line */

{
	if (bar_p == (struct BAR *) 0) {
		return(0.0);
	}

	switch(bar_p->bartype) {

	case SINGLEBAR:
		return(7 * STDPAD);

	case DOUBLEBAR:
		return(9 * STDPAD);

	case ENDBAR:
		return(12 * STDPAD);

	case REPEATSTART:
	case REPEATEND:
		return(16 * STDPAD);

	case REPEATBOTH:
		return(19 * STDPAD);

	case RESTART:
		return(2.0 * HALF_RESTART_WIDTH);

	case INVISBAR:
		return(0.0);

	default:
		pfatal("bad bar type");
		/*NOTREACHED*/
		break;
	}

	/*NOTREACHED*/
	return(0.0);
}
\f

/* Normally, we want some padding on both sides of a bar line,
 * but at the end of a staff, we don't want right padding.
 * This applies either if we are at the right
 * margin or if the next bar is a restart.
 * This function returns how much to adjust an end-of-score bar line
 * eastward to make it at the right edge of the score.
 */

double
eos_bar_adjust(bar_p)

struct BAR *bar_p;	/* the bar to adjust */

{
	double halfbarwidth;

	halfbarwidth = width_barline(bar_p) / 2.0;
	switch (bar_p->bartype) {
	case DOUBLEBAR:
		return(halfbarwidth - STDPAD - (W_NORMAL / PPI / 2.0));
	case SINGLEBAR:
		return(halfbarwidth - (W_NORMAL / PPI / 2.0));
	case REPEATEND:
		return(halfbarwidth - (4.0 * STDPAD) - (W_WIDE / PPI /  2.0));
	case ENDBAR:
		return(halfbarwidth - (2.0 * STDPAD) - (W_WIDE / PPI / 2.0));
	default:
		break;
	}
	return(0.0);
}
\f

/* width of clef, keysig, timesig */

double
width_clefsig(clefsig_p)

struct CLEFSIG *clefsig_p;	/* return width of this clefsig */

{
	/* we just call the routine to print a clefsig, but with
	 * flag to tell it to not really print */
	return(pr_clefsig((struct MAINLL *) 0, clefsig_p, NO));
}
\f

/* translate clef name to clef output character */

int
clefchar(clef)

int clef;	/* TREBLE, etc */

{
	switch(clef) {

	case TREBLE:
	case TREBLE_8:
	case FRENCHVIOLIN:
	case TREBLE_8A:
		return(C_GCLEF);

	case BASS:
		return(C_FCLEF);

	default:
		/* everything else uses the C clef */
		return(C_CCLEF);
	}
}
\f

/* Returns width of the given clef in inches in the default size.
 * If is_small is YES, give width of the 3/4 sized one used in mid-score,
 * rather than the full-sized used at beginning of line.
 * Caller must adjust by staffscale if they need that.
 * No padding is included beyond the padding of the clef music character
 * itself, so caller needs to add any they deem appropriate for aesthetics.
 */

double
clefwidth(clef, is_small)

int clef;	/* TREBLE, BASS, ALTO, FRENCHVIOLIN, etc */
int is_small;	/* If YES, assume mid-score clef, not full sized one */

{
	return(width(FONT_MUSIC, (is_small ? (3 * DFLT_SIZE) / 4 : DFLT_SIZE),
						clefchar(clef)));
}
\f

/* Returns where the given clef's baseline should be
 * relative to the middle line of the staff, in stepsizes.
 * (Above the middle line is positive, below is negative).
 * If north_p and/or south_p are non-null, the relative north/south values
 * of the clef are returned via the pointers. These will be relative
 * to the middle line of the staff and  will be in inches
 * in the default staffscale, using default size
 * (unless is_small == YES, in which case it will be 3/4 size).
 * Note that this should not be called with TABCLEF or NOCLEF.
 */

int
clefvert(clef, is_small, north_p, south_p)

int clef;	/* TREBLE, BASS, ALTO, FRENCHVIOLIN, etc */
int is_small;	/* If YES, assume mid-score clef, not full sized one.
		 * Note that if both of the following arguments are null,
		 * this is_small argument's value is actually irrelevent. */
float *north_p;	/* if non-null, relative north will be returned here */
float *south_p;	/* if non-null, relative south will be returned here */

{
	int steps;	/* relative to middle line, to be returned */

	switch(clef) {

	case TREBLE:
	case TREBLE_8:
	case TREBLE_8A:
		steps = -2;
		break;

	case FRENCHVIOLIN:
	case SOPRANO:
		steps = -4;
		break;

	case MEZZOSOPRANO:
		steps = -2;
		break;

	case ALTO:
		steps = 0;
		break;

	case TENOR:
		steps = 2;
		break;

	case BARITONE:
		steps = 4;
		break;

	case BASS:
		steps = 2;
		break;

	case TABCLEF:
	default:
		pfatal("clefvert called with invalid clef %d", clef);
		/*NOTREACHED*/
		steps = 0;		/* shut up bogus compiler warning */
		break;
	}

	/* If caller wants relative north/south values, calculate them */
	if (north_p != 0 || south_p != 0) {
		char muschar;	/* music character to print for the clef */
		int clefsize;
		char tr8str[4];	/* "8" of treble8 or 8treble */
		float value;	/* of north or south */

		muschar = clefchar(clef);
		clefsize = (is_small ? (3 * DFLT_SIZE) / 4 : DFLT_SIZE);
		tr8str[0] = FONT_TI;
		tr8str[1] = 9;
		tr8str[2] = '8';
		tr8str[3] = '\0';
		
		if (north_p != 0) {
			value = (float) ascent(FONT_MUSIC, clefsize, muschar);
			if (clef == TREBLE_8A) {
				value += (float) strheight(tr8str);
			}
			*north_p = value + (float)(steps * STEPSIZE);
		}

		if (south_p != 0) {
			value = (float) descent(FONT_MUSIC, clefsize, muschar);
			if (clef == TREBLE_8) {
				value += (float) strheight(tr8str);
			}
			*south_p = -value + (float)(steps * STEPSIZE);
		}
	}

	return(steps);
}
\f

/* Given a BLOCKHEAD, fill in its height. BLOCKHEADs are a bit strange,
 * in that they are in a separate coordinate space of unknown size.
 * So we start out assuming it is infinitely thin. Then we check
 * each string in the list and keep track of the lowest one, by
 * pretending to go where it would be printed and adding the descent
 * of the string. At the end, the height must be the page height minus the
 * lowest, since upwards is positive */

static void
set_height_blockhead(blockhead_p, context, mll_p)

struct BLOCKHEAD *blockhead_p;	/* which block to get height of */
int context;			/* C_HEADER, etc */
struct MAINLL *mll_p;		/* for getting margin overrides */

{
	float distance;		/* of headfoot from bottom of page */
	float lowest;
	float x_offset;		/* because of justification */
	float yval;		/* y coordinate value */
	struct PRINTDATA *pr_p;	/* walk through list of things to print */
	float block_width;	/* page width minus margins */
	float s_descent;	/* strdescent() of the current string */
	float extra;		/* how much farther the string descended
				 * than would be expected of a normal,
				 * single line. */
	struct MAINLL *rightmargin_mll_p;	/* mll_p to use for
				 * finding the right margin */


	/* Set _win in this context to zero height at top margin */
	Context = context;
	rightmargin_mll_p = (mll_p ? mll_p->next : 0);
	set_win_coord(blockhead_p->c);
	set_win(PGHEIGHT - EFF_TOPMARGIN, PGHEIGHT - EFF_TOPMARGIN,
		PGWIDTH - eff_rightmargin(rightmargin_mll_p),
		eff_leftmargin(mll_p));
	block_width = PGWIDTH - eff_rightmargin(rightmargin_mll_p) -
							eff_leftmargin(mll_p);

	if (blockhead_p->printdata_p != (struct PRINTDATA *) 0) {
		/* set current to left corner */
		set_cur(eff_leftmargin((struct MAINLL *)0),
						PGHEIGHT - EFF_TOPMARGIN);

		distance = _Cur[AY];

		/* Process each item in the list */
		for (pr_p = blockhead_p->printdata_p;
				pr_p != (struct PRINTDATA *) 0;
				pr_p = pr_p->next) {

			/* If this is a paragraph,
			 * split it into as many lines as needed. */
			if (pr_p->justifytype == J_JUSTPARA ||
					pr_p->justifytype == J_RAGPARA) {
				pr_p->string = split_string(pr_p->string,
								block_width);
			}
			pr_p->width = strwidth(pr_p->string);
			/* stretch justified paragraphs to full width */
			if (pr_p->justifytype == J_JUSTPARA &&
						pr_p->width < block_width) {
				pr_p->width = block_width;
			}

			/* adjust for justification */
			switch (pr_p->justifytype) {

			case J_RIGHT:
				x_offset = pr_p->width;
				break;

			case J_CENTER:
				x_offset = pr_p->width / 2.0;
				break;

			default:
				x_offset = 0.0;
				break;
			}

			/* set current to specified location */
			yval = inpc_y (&(pr_p->location), (char *) 0, -1);
			set_cur( inpc_x( &(pr_p->location), (char *) 0, -1 )
							- x_offset, yval);

			/* if user said to go off of south or y of _win,
			 * change to equivalent offset off of north of _win.
			 * because the  south and y could change */
			if (pr_p->location.vtype == AS ||
					pr_p->location.vtype == AY) {
				if (pr_p->location.vert_p == blockhead_p->c) {
					pr_p->location.vtype = AN;
					pr_p->location.vsteps = (yval
						- (PGHEIGHT - EFF_TOPMARGIN)
						) / STEPSIZE;
				}
			}

			/* determine lowest descent of current string */
			if (pr_p->isPostScript == YES) {
				s_descent = 0.0;
			}
			else {
				s_descent = strdescent(pr_p->string);
			}
			lowest = _Cur[AY] - s_descent;

			/* if lowest of anything found so far, note that */
			if ( lowest < distance) {
				distance = lowest;
				set_win(PGHEIGHT - EFF_TOPMARGIN, distance,
					PGWIDTH - eff_rightmargin((struct MAINLL *)0),
					eff_leftmargin((struct MAINLL *)0));
			}

			/* Set to end of string just "printed."
			 * If the string when down farther than a single line
			 * add in that extra.
			 */
			if (pr_p->isPostScript == YES) {
				extra = 0.0;
			}
			else {
				extra = s_descent - fontdescent(pr_p->string[0],
							pr_p->string[1]);
				if (extra < 0.0) {
					extra = 0.0;
				}
			}
			set_cur( _Cur[AX] + pr_p->width, _Cur[AY] - extra);
		}

		/* set height to lowest distance encountered */
		blockhead_p->height = (PGHEIGHT - distance - EFF_TOPMARGIN);

	}
	else {
		/* empty header/footer */
		blockhead_p->height = 0.0;
	}

	/* if was a footer, now we can set the actual _win coordinates,
 	 * by offsetting from bottom of page instead of top */
	if ( (context == C_FOOTER) || (context == C_FOOT2) ) {
		set_win(EFF_BOTMARGIN + blockhead_p->height, EFF_BOTMARGIN,
			PGWIDTH - eff_rightmargin((struct MAINLL *)0),
			eff_leftmargin((struct MAINLL *)0));
	}
	set_win_coord(0);
}
\f

/* Calculate the height of all blocks, including headers and footers,
 * and fill in the height field of the struct. */

void
calc_block_heights()

{
	struct MAINLL *mll_p;
	double topheight = -1.0;	/* if > 0.0, is height of "top" */
	double botheight = -1.0;	/* if > 0.0, is height of "bottom" */

	debug(2, "calc_block_heights");

	set_height_blockhead(&Header, C_HEADER, 0);
	set_height_blockhead(&Footer, C_FOOTER, 0);
	set_height_blockhead(&Header2, C_HEAD2, 0);
	set_height_blockhead(&Footer2, C_FOOT2, 0);

	/* set main _win to space within margins and header/footer
	 * for first page. */
	Context = C_MUSIC;

	/* set the size of _page */
	_Page[AW] = _Page[AS] = 0.0;
	_Page[AE] = PGWIDTH;
	_Page[AN] = PGHEIGHT;
	_Page[AX] = PGWIDTH / 2.0;
	_Page[AY] = PGHEIGHT / 2.0;

	/* now calculate top/bot and any other blocks in the main list */
	initstructs();
	for (mll_p = Mainllhc_p; mll_p != 0; mll_p = mll_p->next) {
		if (mll_p->str == S_SSV) {
			/* keep margins up to date */
			asgnssv(mll_p->u.ssv_p);
		}
		else if (mll_p->str == S_FEED) {
			if (mll_p->u.feed_p->top_p != 0) {
				set_height_blockhead(mll_p->u.feed_p->top_p,
						C_TOP, 0);
				if (topheight < 0.0) {
					/* save for setting music _win */
					topheight = mll_p->u.feed_p->top_p->height;
				}
			}
			if (mll_p->u.feed_p->top2_p != 0) {
				set_height_blockhead(mll_p->u.feed_p->top2_p,
						C_TOP2, 0);
			}
			if (mll_p->u.feed_p->bot_p != 0) {
				set_height_blockhead(mll_p->u.feed_p->bot_p,
						C_BOT, 0);
				if (botheight < 0.0) {
					/* save for setting music _win */
					botheight = mll_p->u.feed_p->bot_p->height;
				}
			}
			if (mll_p->u.feed_p->bot2_p != 0) {
				set_height_blockhead(mll_p->u.feed_p->bot2_p,
						C_BOT2, 0);
			}
		}
		else if (mll_p->str == S_BLOCKHEAD) {
			set_height_blockhead(mll_p->u.blockhead_p,
						C_BLOCK, mll_p);
		}
	}

	set_win(PGHEIGHT - EFF_TOPMARGIN - Header.height
			- (topheight > 0.0 ? topheight : 0.0),
			EFF_BOTMARGIN + Footer.height
			+ (botheight > 0.0 ? botheight : 0.0),
			PGWIDTH - eff_rightmargin((struct MAINLL *)0),
			eff_leftmargin((struct MAINLL *)0));
}
\f

/* return number of beams or flags to use for a given basic time */

int
numbeams(btime)

int btime;	/* basic time of note to be checked */

{
	int n;

	/* no beams for long notes */
	if (btime <= 4) {
		return(0);
	}

	/* number of beams is equal to the number of bits 4 has to be
	 * shifted left in order to equal the given basic time */
	for (n = 1; (4 << n) <= MAXBASICTIME; n++) {
		if (btime == (4 << n)) {
			return(n);
		}
	}
	return(0);
}
\f

/* given an accidental (#, &, x, B, n) return its music character
 * C_SHARP, etc of the proper size. If not a valid accidental,
 * return 0 */

int acc2char(acc)

int acc;


{
	switch (acc) {

	case '&':
		return(C_FLAT);
	case '#':
		return(C_SHARP);
	case 'n':
		return(C_NAT);
	case 'x':
		return(C_DBLSHARP);
	case 'B':
		return(C_DBLFLAT);
	default:
		/* no accidental */
		return(0);
	}
}
\f

/* get the absolute x and y values for an INPCOORD */
/* get the proper one of the coordinates of the specified location, and
 * add in any offsets */

double
inpc_x(inpcoord_p, fname, lineno)

struct INPCOORD *inpcoord_p;	/* return the x value of this inpcoord */
char *fname;			/* filename, for error message */
int lineno;			/* for error message */

{
	double retval;


	/* if hor_p is null, then this is an absolute coord, rather
	 * than relative to some variable */
	if (inpcoord_p->hor_p == (float *) 0) {
		if (inpcoord_p->counts != 0.0) {
			/* parser should have blocked this case */
			pfatal("can't specify time offset if no variable specified");
		}
		retval = inpcoord_p->hsteps * STEPSIZE;
	}

	/* X location is the x, e, or w value of the specified location
	 * variable, plus any offset plus any time offset */
	else {
		retval = inpcoord_p->hor_p [ inpcoord_p->htype ]
		+ inpcoord_p->hsteps * STEPSIZE
		* coord_staffscale(inpcoord_p->hor_p)
		+ ( inpcoord_p->counts * inpcoord_p->hor_p [INCHPERWHOLE] /
		(double) Score.timeden );
	}

	if (retval < 0.0 || retval > PGWIDTH) {
		if (lineno > 0 && fname != (char *) 0) {
			l_warning(fname, lineno,
				"x value of %f is off the page", retval);
		}
	}
	return(retval);
}
\f

/* given an inpcoord, return its y coordinate */

double
inpc_y(inpcoord_p, fname, lineno)

struct INPCOORD *inpcoord_p;	/* return y value of this inpcoord */
char *fname;			/* filename, for error message */
int lineno;			/* for error message */

{
	double retval;


	/* if vert_p is null, then this is absolute rather than relative */
	if ( inpcoord_p->vert_p == (float *) 0) {
		retval = inpcoord_p->vsteps * STEPSIZE;
	}

	/* Y value is y, n, or s value of specified location variable
	 * plus any vertical offset plus any vsteps offset */
	else {
		retval = inpcoord_p->vert_p [ inpcoord_p->vtype ]
				+ (inpcoord_p->vsteps * STEPSIZE
				* coord_staffscale(inpcoord_p->vert_p));
	}

	if (retval < 0.0 || retval > PGHEIGHT) {
		if (lineno > 0 && fname != (char *) 0) {
			l_warning(fname, lineno,
				"y value of %f is off the page", retval);
		}
	}
	return(retval);
}
\f

/* Given an INPCOORD, return the appropriate staffscale value. Look
 * up which staff, if any, the INPCOORD is associated with, and then get
 * the staffscale out of the SSVs.
 */

static double
coord_staffscale(coord_array)

float *coord_array;

{
	struct COORD_INFO *coord_info_p;


	/* figure out what staffscale value to use, based on
	 * which staff the coordinate is associated with */
	if ((coord_info_p = find_coord(coord_array))
					!= (struct COORD_INFO *) 0 &&
					coord_info_p->staffno != 0) {
		return(svpath(coord_info_p->staffno, STAFFSCALE)->staffscale);
	}
	else {
		return(1.0);
	}
}
\f

/* return the y coordinate of the end of a note stem */
/* (the end farthest from the note head) */

double
find_y_stem(gs_p)

struct GRPSYL *gs_p;	/* which group to get the stem of */

{
	/* error checks */
	if (gs_p == (struct GRPSYL *) 0) {
		pfatal("null group passed to find_y_stem");
	}

	if (gs_p->nnotes == 0) {
		pfatal("group with no notes passed to find_y_stem (from line %d, grpcont %d)",
				gs_p->inputlineno, gs_p->grpcont);
	}

	/* if stem is up, start at bottom note, if down at top */
	if (gs_p->stemdir == UP) {
		return(gs_p->notelist[ gs_p->nnotes - 1].c[AY] + gs_p->stemlen);
	}
	else {
		return(gs_p->notelist[0].c[AY] - gs_p->stemlen);
	}
}
\f

/* return x coordinate of a note stem */

double
find_x_stem(gs_p)

struct GRPSYL *gs_p;	/* return x of stem of this group */

{
	double stem_adjust;	/* to overlap the note head */

	if ( gs_p == (struct GRPSYL *) 0) {
		pfatal("bad group passed to find_x_stem");
	}

	/* if called with something longer than a half note, then there
	 * is no real stem. We must be being called for printing slashes,
	 * so in that case, the x of the "stem" is the x of the group */
	if (gs_p->basictime < 2) {
		return(gs_p->c[AX]);
	}

	/* move stem by half of stem width so edge lines up with edge of note */
	stem_adjust = W_NORMAL / PPI / 2.0;
	if (gs_p->stemdir == UP) {
		stem_adjust = -stem_adjust;
	}
	return(gs_p->c[AX] + (gs_p->stemx + stem_adjust) * Staffscale);
}
\f

/* return the width of a key signature in inches */

double
width_keysig(sharps, naturals)

int sharps;	/* how many sharps to print, or if negative, how many flats. */
int naturals;	/* how many naturals to print for canceling previous key */

{
	double total_width = 0.0;
	int size;

	/* In keysig, things are drawn closer together than
	 * in other places, so to get the total width, we first
	 * multiply the width of the sharp, flat, or natural character
	 * by the number of times it is to be printed, then subtract off
	 * two points for each character printed, except for naturals,
	 * which are only jammed together by one point. */
	
	size = adj_size(DFLT_SIZE, Staffscale, (char *) 0, -1);
	if (sharps >= 1) {
		total_width = (width(FONT_MUSIC, size, C_SHARP) - 2.0 * Stdpad)
					* sharps;
	}
	else if (sharps <= -1) {
		/* negative sharps are flats */
		total_width = (width(FONT_MUSIC, size, C_FLAT) - 2.0 * Stdpad)
					* -sharps;
	}
	if (naturals != 0) {
		total_width += (width(FONT_MUSIC, size, C_NAT) - Stdpad)
				* abs(naturals) + 3.0 * Stdpad;
	}
	return(total_width);
}
\f
/*
 * Name:        nextgrpsyl()
 *
 * Abstract:    Find next GRPSYL in this voice (same measure or not).
 *
 * Returns:     Pointer to the GRPSYL, or 0 if none.
 *
 * Description: This function, given a GRPSYL and the MLL structure it hangs
 *		off of, returns the next GRPSYL in this voice, even if it's in
 *		the next measure.  If it is in the next measure, *mll_p_p gets
 *		updated.  But if that next measure is a second or later ending,
 *		it's not considered to be a "next" measure, so return 0.
 */

struct GRPSYL *
nextgrpsyl(gs_p, mll_p_p)

struct GRPSYL *gs_p;	 /* the given GRPSYL */
struct MAINLL **mll_p_p; /* main linked list structure it is hanging off of */

{
	struct MAINLL *mll_p;	/* point at a MLL item */
	int endingloc;		/* of the following barline */


	/* if not at end of measure, just return the next GRPSYL */
	if (gs_p->next != 0) {
		return (gs_p->next);
	}

	mll_p = *mll_p_p;	/* save original MLL item */

	/*
	 * We hit the end of the measure.  We need to find the first group in
	 * the next measure.  Find the coming bar line, then the corresponding
	 * staff in the next measure.  We do this in case the number of staffs
	 * changes back and forth; we don't want to find the staff in some
	 * later measure.
	 */
	for (*mll_p_p = (*mll_p_p)->next; *mll_p_p != (struct MAINLL *) 0 &&
			(*mll_p_p)->str != S_BAR; *mll_p_p = (*mll_p_p)->next) {
		;
	}

	/* if we hit the end of the MLL, there is no next GRPSYL */
	if (*mll_p_p == (struct MAINLL *) 0) {
		return (struct GRPSYL *) 0;
	}

	/* we found a bar; get its endingloc */
	endingloc = (*mll_p_p)->u.bar_p->endingloc;

	/*
	 * Search for this staff in next measure.  If we find a pseudobar while
	 * doing this, save its endingloc in preference to the real bar's.
	 */
	for (*mll_p_p = (*mll_p_p)->next; *mll_p_p != (struct MAINLL *) 0 &&
			(*mll_p_p)->str != S_BAR &&
			((*mll_p_p)->str != S_STAFF ||
			(*mll_p_p)->u.staff_p->staffno != gs_p->staffno);
			*mll_p_p = (*mll_p_p)->next) {

		if ((*mll_p_p)->str == S_CLEFSIG && 
		    (*mll_p_p)->u.clefsig_p->bar_p != (struct BAR *) 0) {
			endingloc = (*mll_p_p)->u.clefsig_p->bar_p->endingloc;
		}
	}

	/* if we hit the end or another bar before finding our staff, return */
	if (*mll_p_p == (struct MAINLL *) 0 || (*mll_p_p)->str == S_BAR) {
		return (struct GRPSYL *) 0;
	}

	/*
	 * We found the appropriate staff in the next measure.  But if we have
	 * crossed into a second or later ending, this bar doesn't really
	 * "follow" the previous bar, and we must return null.  So if endingloc
	 * shows this is the case, we must search backwards to find out if we
	 * were already in an ending.
	 */
	if (endingloc == STARTITEM) {
		while (mll_p != 0 && mll_p->str != S_BAR && (mll_p->str !=
				S_CLEFSIG || mll_p->u.clefsig_p->bar_p == 0))
			mll_p = mll_p->prev;

		/* set endingloc of the previous measure */
		if (mll_p == 0) {
			endingloc = NOITEM;
		} else if (mll_p->str == S_BAR) {
			endingloc = mll_p->u.bar_p->endingloc;
		} else {
			endingloc = mll_p->u.clefsig_p->bar_p->endingloc;
		}

		/* if we were already in an ending, there's no next GRPSYL */
		if (endingloc == STARTITEM || endingloc == INITEM) {
			return (struct GRPSYL *) 0;
		}
	}

	/* return the first GRPSYL of the appropriate voice */
	return ((*mll_p_p)->u.staff_p->groups_p[ gs_p->vno - 1 ]);
}
\f
/*
 * Name:        prevgrpsyl()
 *
 * Abstract:    Find previous GRPSYL in this voice (same measure or not).
 *
 * Returns:     Pointer to the GRPSYL, or 0 if none.
 *
 * Description: This function, given a GRPSYL and the MLL structure it hangs
 *		off of, returns the previous GRPSYL in this voice, even if it's
 *		in an earlier measure.  If we are at the start of an ending,
 *		it skips over any previous ending and goes to the measure
 *		preceding the first ending.  If the resulting GRPSYL is in a
 *		previous measure, *mll_p_p gets updated.
 */

struct GRPSYL *
prevgrpsyl(gs_p, mll_p_p)

struct GRPSYL *gs_p;	 /* the given GRPSYL */
struct MAINLL **mll_p_p; /* main linked list structure it is hanging off of */

{
	struct GRPSYL *gs2_p;	/* for looping through prev measure's list */
	struct BAR *bar_p;	/* point at a bar line */
	struct MAINLL *mll_p;	/* point at a MLL item */
	int pseudo;		/* was the last thing we saw a pseudobar? */
	int barcount;		/* how many bar lines we looped backward thru*/
	int safmoae;		/* "started at first measure of an ending" */


	/* if not at start of measure, just return the previous GRPSYL */
	if (gs_p->prev != (struct GRPSYL *) 0) {
		return (gs_p->prev);
	}

	/*
	 * We hit the start of the measure.  Loop backwards through the MLL
	 * looking for the bar line at the start of the "previous" measure.
	 * If our measure is not the first measure of an ending, this is
	 * simply the bar at the start of the previous measure.  Otherwise,
	 * this is the bar before the measure before the first ending.  Also
	 * handle the cases where we fall off the start of the MLL.
	 */
	bar_p = 0;
	mll_p = *mll_p_p;
	pseudo = NO;
	barcount = 0;
	safmoae = NO;
	do {
		/* find preceding bar or pseudobar, if either exists */
		for (mll_p = mll_p->prev; mll_p != (struct MAINLL *) 0 &&
				mll_p->str != S_BAR &&
				(mll_p->str != S_CLEFSIG ||
				mll_p->u.clefsig_p->bar_p == 0);
				mll_p = mll_p->prev) {
			;
		}

		/*
		 * If we hit the start of the MLL without crossing any bars, or
		 * just a pseudobar, there is no preceding GRPSYL, so return 0.
		 * (Depending on who is calling this function, the pseudobar at
		 * the start of the song may or may not exist.)  Otherwise, it
		 * must be that we started in the second measure, or an ending
		 * that we skipped over started there.  Point at the start of
		 * the MLL, and get out of the loop.  Note that we can't still
		 * be in the process of skipping over endings:  no ending can
		 * start at the first measure of the song, because there is no
		 * bar line there.
		 */
		if (mll_p == 0) {
			if (barcount == 0 || (barcount == 1 && pseudo == YES)) {
				return (struct GRPSYL *) 0;
			}
			mll_p = Mainllhc_p;
			break;
		}

		barcount++;

		/*
		 * Point bar_p at the relevant bar/pseudobar for checking the
		 * endingloc.  If this is a pseudobar, it's relevant.  If this
		 * is a bar, it's relevant only if it's the first thing we've
		 * seen, or the thing we saw last was not a pseudobar.  That
		 * is, the endingloc of the bar at the end of a score is to be
		 * ignored, because the true endingloc has been moved to the
		 * next score's pseudobar.  We need to worry about this because
		 * of the case where a second ending starts at the start of the
		 * new score (STARTITEM) and the previous score ends with
		 * ENDITEM, which should be ignored.
		 */
		if (mll_p->str == S_BAR) {
			if (bar_p == 0 || pseudo == NO) {
				bar_p = mll_p->u.bar_p;
			}
			if (pseudo == YES) {
				barcount--;	/* forget this bar */
				pseudo = NO;
			}
		} else {
			bar_p = mll_p->u.clefsig_p->bar_p;
			pseudo = YES;
		}

		/*
		 * If this is the first measure we're backing into, and this
		 * first bar we hit shows that our GRPSYL was in the first
		 * measure of an ending, remember that fact.
		 */
		if (barcount == 1 && bar_p->endingloc == STARTITEM) {
			safmoae = YES;
		}

	/*
	 * Get out, when, in the normal case, we've hit the second meaningful
	 * bar; or in the safmoae case, we've skipped back to the back before
	 * the first bar of the first ending.
	 */
	} while (! ( (safmoae == NO && barcount == 2) || (safmoae == YES &&
		(bar_p->endingloc == NOITEM || bar_p->endingloc == ENDITEM))));

	/*
	 * Search forward to the next bar, which is the bar before which we
	 * want to find a GRPSYL.  We don't care about pseudobars here.
	 */
	for (mll_p = mll_p->next; mll_p->str != S_BAR; mll_p = mll_p->next) {
		;
	}

	/*
	 * Now mll_p is the bar before which we want to find the GRPSYL.
	 * Find the corresponding staff in the previous measure.  We do
	 * this in case the number of staffs changes back and forth; we
	 * don't want to find the staff in some earlier measure.
	 */

	/* search for this staff in previous measure */
	for (*mll_p_p = mll_p->prev; *mll_p_p != (struct MAINLL *) 0 &&
			(*mll_p_p)->str != S_BAR &&
			((*mll_p_p)->str != S_STAFF ||
			(*mll_p_p)->u.staff_p->staffno != gs_p->staffno);
			*mll_p_p = (*mll_p_p)->prev) {
		;
	}

	/* if we hit the start or another bar before finding our staff, return*/
	if (*mll_p_p == (struct MAINLL *) 0 || (*mll_p_p)->str == S_BAR) {
		return (struct GRPSYL *) 0;
	}

	/* return the last GRPSYL of the appropriate voice */
	gs2_p = (*mll_p_p)->u.staff_p->groups_p[ gs_p->vno - 1 ];
	if (gs2_p == (struct GRPSYL *) 0) {
		return(gs2_p);
	}
	while (gs2_p->next != (struct GRPSYL *) 0) {
		gs2_p = gs2_p->next;
	}

	return (gs2_p);
}
\f

/* if user asked for octave marks, we need to transpose any affected notes
 * by the appropriate number of octaves. This should be called for a measure
 * at a time. It will handle all the octave marks
 * within the measure for the current voice, both those carrying over into
 * this measure and ones starting there. If an octave mark spills beyond
 * the end of the measure, the amount to transpose and how long to do so
 * is saved away for use in the next measure. Checks for things becoming
 * out of range because of the transposition are not done here; caller
 * must do that if they care. */

void
octave_transpose(staff_p, mll_p, vno, normdir)

struct STAFF *staff_p;
struct MAINLL *mll_p;	/* staff_p connects here, used for bends */
int vno;		/* voice number */
int normdir;		/* YES if should move note pitches up for above and
			 * down for below. NO if the inverse should be done */

{
	struct GRPSYL *gs_p;	/* walk through list of GRPSYLs */
	struct GRPSYL *gs_roll_p;	/* group generated for a roll */
	struct STUFF *stuff_p;	/* to look for octave marks */
	RATIONAL total_time;	/* accumulated time in measure */
	float float_total_time;	/* for comparing with count */
	int carry_adjust;	/* adjust to carry into next measure */
	int carry_bars;		/* how many bars to carry over */
	float carry_counts;	/* how many counts in final bar */
	int staffno;		/* which staff we are working with */


	staffno = staff_p->staffno;
	carry_adjust = carry_bars = 0;
	carry_counts = 0.0;

	/* if currently have octave mark */
	if (Octave_adjust[staffno] != 0) {

		/* if bar count > 0, transpose all notes in measure */
		if (--(Octave_bars[staffno]) > 0) {

			for (gs_p = staff_p->groups_p[vno];
					gs_p != (struct GRPSYL *) 0;
					gs_p = gs_p->next) {

				grp_octave_adjust(gs_p, Octave_adjust[staffno], mll_p);
			}
		}

		/* otherwise just transpose until specified time */
		else {
			total_time = Zero;
			for (gs_p = staff_p->groups_p[vno];
						gs_p != (struct GRPSYL *) 0;
						gs_p = gs_p->next) {

				float_total_time = RAT2FLOAT(total_time)
						* Score.timeden + 1.0;

				if (float_total_time <= Octave_count[staffno]) {
					grp_octave_adjust(gs_p,
						Octave_adjust[staffno], mll_p);
				}
				else {
					break;
				}
				total_time = radd(total_time, gs_p->fulltime);
			}

			Octave_adjust[staffno] = 0;
		}
	}

	/* go through stuff list. If any octave marks, transpose appropriate
	 * notes in this measure. If extends to next measure, remember for
	 * next time. If user put in more than one octave
	 * mark going over the bar, catch that. If there are overlaps within
	 * a measure, it seems like too much trouble to catch this, so just
	 * transpose as often as they say and let them figure out why it
	 * sounds funny. */
	for (stuff_p = staff_p->stuff_p; stuff_p != (struct STUFF *) 0;
						stuff_p = stuff_p->next) {

		if (stuff_p->stuff_type == ST_OCTAVE) {

			if (Octave_adjust[staffno] != 0) {
				l_warning(stuff_p->inputfile,
						stuff_p->inputlineno,
						"overlapping octave marks");
			}

			/* figure out how many octaves to move */
			Octave_adjust[staffno] = parse_octave(stuff_p->string,
					stuff_p->place, stuff_p->inputfile,
					stuff_p->inputlineno);

			/* if this call is for inverse transpostion, adjust
			 * to go in opposite direction */
			if (normdir == NO) {
				Octave_adjust[staffno] *= -1;
			}

			/* figure out to which count the octave mark applies
			 * within this measure. */
			Octave_count[staffno] = (stuff_p->end.bars > 0 ? 1.0 +
					RAT2FLOAT(Score.time) * Score.timeden
					: stuff_p->end.count);
			
			total_time = Zero;
			for (gs_p = staff_p->groups_p[vno];
						gs_p != (struct GRPSYL *) 0;
						gs_p = gs_p->next) {

				float_total_time = RAT2FLOAT(total_time) *
						Score.timeden + 1.0;
				if (float_total_time >= stuff_p->start.count) {

					if (float_total_time <=
							Octave_count[staffno]) {
						/* is within the mark, so move */
						grp_octave_adjust(gs_p,
							Octave_adjust[staffno],
							mll_p);
					}

					/* special case. If we have a rolled
					 * chord, and user specified
					 * an octave mark without a til clause,
					 * all the chords that got
					 * generated internally to cause the
					 * "roll" effect need to be transposed,
					 * even though they have been moved
					 * in time */
					if (float_total_time == stuff_p->start.count
						&& stuff_p->end.bars == 0
						&& stuff_p->end.count == 0.0
						&& gs_p->inputlineno < 0) {

					    /* adjust all the groups generated
					     * to create the roll effect */
					    for (gs_roll_p = gs_p->next;
							gs_roll_p != (struct GRPSYL *) 0;
							gs_roll_p = gs_roll_p->next) {

					    	    grp_octave_adjust(gs_roll_p,
							Octave_adjust[staffno],
							mll_p);
						    /* stop when we hit the
						     * end of the roll */
						    if (gs_roll_p->inputlineno > 0) {
							break;
						    }
					    }
					}
				}

				total_time = radd(total_time, gs_p->fulltime);
			}

			/* if octave mark carried over into subsequent
			 * measure(s), make a note of that for future use */
			if (stuff_p->end.bars > 0) {
				if (carry_adjust != 0) {
					l_warning(stuff_p->inputfile,
						stuff_p->inputlineno,
						"overlapping octave marks");
				}
				carry_bars = stuff_p->end.bars;
				carry_counts = stuff_p->end.count;
				carry_adjust = Octave_adjust[staffno];
			}

			Octave_adjust[staffno] = 0;
		}
	}

	/* above octave marks that were put in on the same input line will
	 * be in backwards order (because above stuff needs to be that
	 * way to pile on correctly). However, if the last octave in the
	 * stuff input line carried over a bar line, we would see it
	 * first and lose the carryover information when handling the earlier
	 * octave marks (which are later in the stuff list). That's why the
	 * carryover information had to be saved. Now we can assign it */
	if (carry_bars > 0) {
		Octave_adjust[staffno] = carry_adjust;
		Octave_bars[staffno] = carry_bars;
		Octave_count[staffno] = carry_counts;
	}
}
\f

/* transpose all the notes in a group by the specified octave adjustment */

static void
grp_octave_adjust(gs_p, adj, mll_p)

struct GRPSYL *gs_p;		/* adjust this group */
int adj;			/* add this (potentially negative) value to
				 * each notelist octave */
struct MAINLL *mll_p;		/* STAFF of gs_p for finding prev grp for bends */

{
	register int n;
	struct GRPSYL *prevgs_p;	/* previous group, for bends */

	for (n = 0; n < gs_p->nnotes; n++) {
		gs_p->notelist[n].octave += adj;
	}
	/* Transpose any bends going to this group */
	prevgs_p = prevgrpsyl(gs_p, &mll_p);
	if (prevgs_p == 0) {
		/* If there is no previous group, nothing to transpose. */
		return;
	}
	for (n = 0; n < prevgs_p->nnotes; n++) {
		if (prevgs_p->notelist[n].is_bend == YES) {
			/* Note that when is_bend is YES, nslurto will always
			 * be 1, but we loop through as many as there are
			 * (all 1 of them!), to not be dependent
			 * on that piece of inside information.
			 */
			int s;
			for (s = 0; s < prevgs_p->notelist[n].nslurto; s++) {
				prevgs_p->notelist[n].slurtolist[s].octave += adj;
			}
		}
	}
}
\f

/* Given a group and note value, return the effective accidental
 * on that note, (-2 to +2) taking key signature
 * and previous accidentals into account.
 * There are certain pathological cases that this doesn't
 * handle right, notably if the user changes the key signature at a bar
 * line, and the note in question is tied to from before that bar line,
 * and the key signature change is such that it changes what the accidental
 * should be. But it should handle anything less convoluted than that.
 */

int
eff_acc(gs_p, note_p, mll_p)

struct GRPSYL *gs_p;	/* get effective accidental for note in this group */
struct NOTE *note_p;	/* get for this note */
struct MAINLL *mll_p;	/* main list item that points to gs_p */

{
	struct MAINLL *orig_mll_p;
	struct GRPSYL *pgs_p;		/* previous group */
	int n;
	int tie_break;			/* YES if there has been a break
					 * in the chain of notes
					 * tied together */
	int eff_accidental;		/* effective accidental so far */


	/* if this group has an explicit accidental, that's also the
	 * effective accidental */
	if (note_p->accidental != '\0') {
		/* note: the - 2 is to adjust for natural being element 2
		 * of the Circle array */
		return( (int) (strchr(Acclets, note_p->accidental) - Acclets) - 2);
	}

	/* remember which measure we are starting in, so we know when we cross
	 * a bar line */
	orig_mll_p = mll_p;

	/* init to assume we might have ties */
	tie_break = NO;

	/* if all else fails, we will use the accidental from the key sig */
	eff_accidental = acc_from_keysig(note_p->letter, gs_p->staffno,
						mll_p);

	/* back up until we figure out the effective accidental */
	for (pgs_p = prevgrpsyl(gs_p, &mll_p); pgs_p != (struct GRPSYL *) 0;
				pgs_p = prevgrpsyl(pgs_p, &mll_p)) {


		/* see if this group contains the note in question */
		for (n = 0; n < pgs_p->nnotes; n++) {
			if (pgs_p->notelist[n].letter == note_p->letter &&
						pgs_p->notelist[n].octave
						== note_p->octave) {
				/* it does have the note: it's notelist[n] */
				break;
			}
		}

		/* see if this is end of ties to the note, working backwards */
		if (n == pgs_p->nnotes) {
			/* no note at all, so clearly no tied note */
			tie_break = YES;
		}
		else if (pgs_p->notelist[n].tie == NO) {
			/* end of chain of tied notes */
			tie_break = YES;
		}

		if (orig_mll_p == mll_p) {
			/* we're still in same measure. If we have a matching
			 * note, see if it has an accidental */
			if (n < pgs_p->nnotes) {
				if (pgs_p->notelist[n].accidental != '\0') {
					return( (int) (strchr(Acclets,
						pgs_p->notelist[n].accidental)
						- Acclets) - 2);
				}
			}

			/* have to keep backing up */
		}
		else {
			/* Now in previous measure. If no matching note,
			 * we use the effective accidental found so far */
			if (n == pgs_p->nnotes) {
				return(eff_accidental);
			}

			/* if the note isn't tied, then use the most recent
			 * effective accidental we found */
			if (pgs_p->notelist[n].tie == NO || tie_break == YES) {
				return(eff_accidental);
			}

			/* if there is an accidental on this note,
			 * then it's the one we're looking for. */
			if (pgs_p->notelist[n].accidental != '\0') {
				return( (int) (strchr(Acclets,
					pgs_p->notelist[n].accidental) -
					Acclets - 2));
			}

			/* need to continue working backwards toward
			 * the beginning of this new measure */
			orig_mll_p = mll_p;
			eff_accidental = acc_from_keysig(note_p->letter,
					gs_p->staffno, mll_p);
		}
	}

	/* backed up all the way to the beginning of the song, use last we
	 * found */
	return(eff_accidental);
}
\f

/* given a letter and staff number, return 1 if the pitch with that letter
 * gets a sharps according to the key signature,  or -1 if it gets a flat,
 * or 0 if it gets neither. */

int
acc_from_keysig(letter, staffno, mll_p)

int letter;		/* which pitch */
int staffno;		/* which staff to get the key signature from */
struct MAINLL *mll_p;	/* pitch is from the staff hanging off of here */

{
	int index;	/* where the letter is in circle of fifths */
	int sharps;	/* sharps in key sig for the given staff */
	struct SSV *ssv_p;	/* to get key signature */


	/* find letter in circle of fifths */
	index = strchr(Circle, letter) - Circle + 1;

	/* get key signature. Unfortunately, the SSVs may not be
	 * accurate at the time we are called, so we have to search
	 * backwards in the main list for the most recent relevant
	 * key signature change. */
	for (sharps = 0; mll_p != (struct MAINLL *) 0; mll_p = mll_p->prev) {
		if (mll_p->str == S_SSV) {
			ssv_p = mll_p->u.ssv_p;

			/* does this SSV have a key signature change in it? */
			if (ssv_p->used[SHARPS] == YES) {
				if (ssv_p->context == C_STAFF &&
						ssv_p->staffno == staffno) {
					/* aha! found the most recent
					 * key signature
					 * for the relevant staff */
					sharps = ssv_p->sharps;
					break;
				}
				else if (ssv_p->context == C_SCORE) {
					/* this will be the score-wide default
					 * if we don't find a staff-specific
					 * value, so save this as our default */
					sharps = ssv_p->sharps;
				}
			}
		}
	}

	if (sharps > 0) {
		/* key signature is one with sharps */
		if (index <= sharps) {
			/* this letter gets a sharp */
			return(1);
		}
	}
	else if (sharps < 0) {
		/* key signature is one with flats */
		if ( (8 - index) <= -sharps) {
			/* this letter gets a flat */
			return(-1);
		}
	}

	/* must be a natural */
	return(0);
}

/* Set Staffscale, Stepsize, Stdpad, and other similar values based on the
 * specified staff number. If staff of 0 is given, set Staffscale to the
 * score value
 */

void
set_staffscale(s)

int s;			/* which staff */

{
	Staffscale = (s == 0 ? Score.staffscale
					: svpath(s, STAFFSCALE)->staffscale);
	Stepsize = STEPSIZE * Staffscale;
	Stdpad = STDPAD * Staffscale;
	Flagsep = FLAGSEP * Staffscale;
	Smflagsep = SMFLAGSEP * Staffscale;
	Tupheight = TUPHEIGHT * Staffscale;
}
\f

/* Determine the space between lines of a grid. A staff of 0 means use
 * the score size. A staff of -1 means ATEND. Return distance in inches. */

double
gridspace(staff)

int staff;

{
	double space;

	if (staff == -1) {
		space = ATEND_GS * STEPSIZE * Score.gridscale;
	}
	else {
		space = WHEREUSED_GS * STEPSIZE
				* svpath(staff, STAFFSCALE)->staffscale
				* svpath(staff, GRIDSCALE)->gridscale;
	}
	return(space);
}
\f

/* Given a grid, return (via pointer) the items needed for the PostScript
 * plus the top fret.
 */

void
gridinfo(grid_p, staff, frets_p, fretnum_p, numvert_p, topfret_p)

struct GRID *grid_p;
int staff;	/* 0 == score, -1 = ATEND, otherwise the staff number */
int *frets_p;	/* how many frets high the grid should be */
int *fretnum_p;	/* the N of "N fr" */
int *numvert_p;	/* how many frets from the top to print the "N fr" */
int *topfret_p; /* the fret number of the top line of the grid */

{
	int minfret, maxfret;	/* smallest and largest frets used */
	int rightmost_fret;	/* the 'N' of 'N fr" if any */
	int right_stringnum;	/* string number having rightmost_fret */
	int mincurvefret;	/* smallest fret number inside curve */
	int has_o;		/* if there are 'o' items */
	int gridfret;
	int s;


	/* Go through strings finding min/max/rightmost */
	minfret = MAXFRET + 1;
	maxfret = MINFRET - 1;
	mincurvefret = MAXFRET + 1;
	has_o = NO;
	rightmost_fret = right_stringnum = 0;  /* avoids bogus warnings */
	for (s = 0; s < grid_p->numstr; s++) {
		/* x o and - things don't count */
		if (grid_p->positions[s] > 0) {
			if (grid_p->positions[s] < minfret) {
				minfret = grid_p->positions[s];
			}
			if (grid_p->positions[s] > maxfret) {
				maxfret = grid_p->positions[s];
			}
			rightmost_fret = grid_p->positions[s];
			right_stringnum = s;

			/* find smallest fret inside curve */
			if (grid_p->curvel != 0 && s >= grid_p->curvel - 1 &&
					s <= grid_p->curver - 1 &&
					grid_p->positions[s] < mincurvefret) {
				mincurvefret = grid_p->positions[s];
			}
		}
		else if (grid_p->positions[s] == 0) {
			has_o = YES;
		}
	}

	/* set the values to defaults, then calculate actuals if needed */
	*frets_p = 5;
	*fretnum_p = 0;
	*numvert_p = 0;
	if (minfret <= MAXFRET) {
		/* at least one fret was used */

		/* figure out how many frets tall to make the grid */
		*frets_p = maxfret + 1;

		/* see if gridfret is set */
		gridfret = svpath(staff == -1 ? 0 : staff, GRIDFRET)->gridfret;
		if (gridfret != NOGRIDFRET) {
			/* gridfret is set; see if all frets larger than that.
			 * But we only use "N fr" if there are no 'o' items. */
			if (has_o == NO && minfret >= gridfret) {
				/* We will need "N fr"
				 * Usually we use the rightmost string
				 * that has a fret on it,
				 * but there is one special case:
				 * if the curve comes at least that far right,
				 * and the minimum fret inside the curve is
				 * smaller than the rightmost_fret, then we
				 * put the "N fr" by the curve minimum.
				 */
				if (grid_p->curver - 1 >= right_stringnum
						&& mincurvefret < rightmost_fret) {
					rightmost_fret = mincurvefret;
				}
				*fretnum_p = rightmost_fret;
				*numvert_p = rightmost_fret - minfret + 1;
				*frets_p = maxfret - minfret + 2;
			}
		}

		if (*frets_p < 5) {
			/* always at least 4 frets plus top line */
			*frets_p = 5;
		}
	}
	*topfret_p = (*fretnum_p == 0 ? 0 : *fretnum_p - *numvert_p);
}
\f

/* Determine the dimensions of a grid, relative to a point in the middle
 * of the top line of the grid, and return them via pointers.
 * If pointers are 0, don't bother; caller doesn't care about these things.
 * Things in this function must be kept in sync with the PostScript prolog
 * definition of grids.
 */

void
gridsize(grid_p, staff, north_p, south_p, east_p, west_p)

struct GRID *grid_p;	/* find the size of this grid */
int staff;		/* use this staff for scaling. 0 means score,
			 * -1 means ATEND */
float *north_p;		/* return values... */
float *south_p;
float *east_p;
float *west_p;

{
	double space;	/* distance between adjacent line of the grid */
	int frets;
	int fretnum;
	int numvert;
	int topfret;
	int s;		/* string index */

	if (grid_p == 0) {
		pfatal("gridsize() was passed a null pointer");
	}

	/* determine distance between grid lines and other needed info */
	space = gridspace(staff);
	gridinfo(grid_p, staff, &frets, &fretnum, &numvert, &topfret);

	/* Start with minimum. East and west are equal, at half the
	 * total grid width, based on number of strings. The number of
	 * spaces is the number of strings minus one, but dots, X's,
	 * and O's will hang over the sides, so use the number of strings.
	 * Then adjust east for "N fr" if needed. */
	if (west_p != 0) {
		*west_p = -((space * grid_p->numstr) / 2.0);
	}
	if (east_p != 0) {
		*east_p = (space * grid_p->numstr) / 2.0;
		if (fretnum > 0) {
			/* We will need "N fr".
			 * Get enough space to hold
			 * font, size, 2 digits, space, "fr", null */
			char tmp[8];

			/* this is printed in Palatino Roman */
			tmp[0] = (char) FONT_PR;

			/* Between staffscale and gridscale,
			 * we could get a size that we can't represent
			 * in internal format, so get string width
			 * in default size and adjust afterwards. */
			tmp[1] = (char) DFLT_SIZE;

			/* since we know there are no funny characters
			 * in this string, we can cheat and not bother
			 * to call the string normalizer. */
			sprintf(tmp + 2, "%d fr", fretnum);

			*east_p += strwidth(tmp) *
						(space * PPI * 1.9)/ DFLT_SIZE;
		}
	}

	if (north_p != 0) {
		/* Always put almost one space of padding on top, which allows
		 * room for x's and o's and curves. Even if this particular grid
		 * doesn't have those, many do, so it's nice to line
		 * all of them up as much as possible */
		*north_p = 0.85 * space;
		/* If there is a curve above the top fret,
		 * with x's or o's above it, leave some more space */
		if (grid_p->positions[grid_p->curvel - 1] == topfret + 1 
					|| grid_p->positions[grid_p->curver - 1]
					== topfret + 1) {
			for (s = grid_p->curvel; s <= grid_p->curver; s++) {
				if (grid_p->positions[s-1] == 0 ||
						grid_p->positions[s-1]
						== -1) {
					*north_p += 0.7 * space;
					break;
				}
			}
		}
	}

	/* Grid is always at least 4 boxes high, more if needed,
	 * plus 1/2 space of padding at bottom */
	if (south_p != 0) {
		*south_p = -(frets - 0.5) * space;
	}
}
\f

/* This function returns the minimum distance needed between the current 
 * staff and previous one, given their clefs and allowing for a measure
 * number. The clefs might be NOCLEF, like if this is for the top
 * staff of a page or a staff where printclef is false.
 */
 
double
clefspace(prevclef, prevscale, curclef, curscale, measnum)

int prevclef;		/* clef on staff above */
double prevscale;	/* staffscale for the staff above */
int curclef;		/* clef on staff below */
double curscale;	/* staffscale for the staff below */
int measnum;		/* YES if a measure number needs to be printed */

{
	double cur_extend;	/* space needed for current clef */
	double prev_extend;	/* space needed for clef above */
	double space_needed;	/* total for both clefs and measure number */


	/* Figure out how much the clef on current staff sticks up,
	 * Do in approximate STEPSIZEs here, and adjust later for scale. */
	switch (curclef) {
	case TREBLE_8A:
		cur_extend = 6.0;
		break;
	case TREBLE:
	case TREBLE_8:
		cur_extend = 4.0;
		break;
	case BARITONE:
		cur_extend = 4.2;
		break;
	case TENOR:
		cur_extend = 2.2;
		break;
	case FRENCHVIOLIN:
		cur_extend = 2.0;
		break;
	default:
		cur_extend = 0.0;
		break;
	}

	/* Similar for the clef above, only how much it sticks down
	 * rather than up */
	switch (prevclef) {
	case TREBLE:
	case TREBLE_8A:
		prev_extend = 3.2;
		break;
	case MEZZOSOPRANO:
		prev_extend = 2.2;
		break;
	case SOPRANO:
		prev_extend = 4.2;
		break;
	case FRENCHVIOLIN:
	case TREBLE_8:
		prev_extend = 5.2;
		break;
	default:
		prev_extend = 0.0;
		break;
	}

	/* Add top and bottom together, adjusting for scale factors,
	 * and adding a little padding */
	space_needed = prev_extend * STEPSIZE * prevscale +
			cur_extend * STEPSIZE * curscale +
			STDPAD * curscale;

	/* Add on the space for the measure number, if necessary.
	 * Note that we can use fontascent since all digits are that high. */
	if (measnum == YES) {
		space_needed += fontascent(Score.measnumfamily + Score.measnumfont,
				Score.measnumsize) + STDPAD;
	}
	return(space_needed);
}
\f
/*
 * Name:        eff_rightmargin()
 *
 * Abstract:    Return the effective right margin for this score.
 *
 * Returns:     the margin in inches
 *
 * Description: There are two reason that code can't just use Score.rightmargin
 *		but must call this function.  First, the way the "scale" param
 *		works, we pretend the paper is smaller by that amount and then
 *		in PostScript magnify it back to the real size; but margins are
 *		not to be scaled, so we have to fake out the code by dividing
 *		out the scale here.  Second, the user can override the param
 *		on a "newscore" or "newpage".  To ignore a user override, pass
 *		0 for mainll_p, else pass some MLL on that score.
 */

double
eff_rightmargin(mainll_p)

struct MAINLL *mainll_p; /* MLL struct on some score, or 0 for normal margin */

{
	/* if not already at a FEED, find FEED at right end of this score */
	while (mainll_p != 0 && mainll_p->str != S_FEED)
		mainll_p = mainll_p->next;

	/* if there is none, or there is no override, use the parameter */
	if (mainll_p == 0 || mainll_p->u.feed_p->rightmargin < 0.0)
		return (Score.rightmargin / Score.scale_factor);

	/* use this override value */
	return (mainll_p->u.feed_p->rightmargin / Score.scale_factor);
}
\f
/*
 * Name:        eff_leftmargin()
 *
 * Abstract:    Return the effective left margin for this score.
 *
 * Returns:     the margin in inches
 *
 * Description: There are two reason that code can't just use Score.leftmargin
 *		but must call this function.  First, the way the "scale" param
 *		works, we pretend the paper is smaller by that amount and then
 *		in PostScript magnify it back to the real size; but margins are
 *		not to be scaled, so we have to fake out the code by dividing
 *		out the scale here.  Second, the user can override the param
 *		on a "newscore" or "newpage".  To ignore a user override, pass
 *		0 for mainll_p, else pass some MLL on that score.
 */

double
eff_leftmargin(mainll_p)

struct MAINLL *mainll_p; /* MLL struct on some score, or 0 for normal margin */

{
	/* if not already at a FEED, find FEED at left end of this score */
	while (mainll_p != 0 && mainll_p->str != S_FEED)
		mainll_p = mainll_p->prev;

	/* if there is none, or there is no override, use the parameter */
	if (mainll_p == 0 || mainll_p->u.feed_p->leftmargin < 0.0)
		return (Score.leftmargin / Score.scale_factor);

	/* use this override value */
	return (mainll_p->u.feed_p->leftmargin / Score.scale_factor);
}
\f
/*
 * Name:        findprimes()
 *
 * Abstract:    Find all the prime numbers up to the given number ("max").
 *
 * Returns:     array indexed 0 to max, each element YES or NO (is index prime?)
 *
 * Description: This function mallocs and returns an array of shorts, indexed
 *		from 0 to max.  Each element is YES or NO, telling whether its
 *		index is a prime number.  The first time it is called, or if
 *		max is greater than the previous time, it calculates all this,
 *		but on other calls it just returns the answer from before.
 */

short *
findprimes(max)

int max;		/* max integer we need to consider */

{
	static short *isprime = 0;	/* array to be malloc'ed */
	static int oldmax = 0;		/* the max passed in previously */
	int stop;			/* where to stop looking */
	int prime;			/* a prime number */
	int n;				/* loop index */


	/* if we've already been here ... */
	if (isprime != 0) {
		/* if we've already done the same or more, just return answer*/
		if (max <= oldmax) {
			return (isprime);
		}
		/* max increased; free the old array */
		FREE(isprime);
	}
	oldmax = max;		/* remember if for next time */

	MALLOCA(short, isprime, max + 1);

	/* 0 and 1 are not primes */
	isprime[0] = isprime[1] = NO;

	/*
	 * We're going to use the Sieve of Eristosthenes.  We start out by
	 * assuming everything 2 and greater is prime.
	 */
	for (n = 2; n <= max; n++) {
		isprime[n] = YES;
	}

	/* the following loop can stop when it gets to this point */
	stop = sqrt((double)max) + 1;

	prime = 2;
	while (prime <= stop) {
		/* knock out all multiples of this prime number */
		for (n = 2 * prime; n <= max; n += prime) {
			isprime[n] = NO;
		}
		/* find the next prime */
		for (n = prime + 1; n <= stop && isprime[n] == NO; n++)
			;
		prime = n;
	}

	return (isprime);
}
\f
/*
 * Name:        factor()
 *
 * Abstract:    Factor the given number.
 *
 * Returns:     array indexed 0 to num, giving the prime factors
 *
 * Description: This function mallocs and returns an array of shorts, indexed
 *		from 0 to max.  Each element indexed by a prime number tells
 *		how many times that prime factor occurs in num.  All other
 *		elements are 0.  The first time it is called, or if num is
 *		different from the previous time, it calculates all this,
 *		but on other calls it just returns the answer from before.
 */

short *
factor(num)

int num;		/* the integer to be factored */

{
	static short *factors = 0;	/* array to be malloc'ed */
	static int oldnum = 0;		/* the number passed in previously */
	short *isprime;			/* list of which numbers are prime */
	int orignum;			/* remember original num */
	int n;				/* loop index */


	/* if we've just done the same number, just return the answer */
	if (factors != 0) {
		/* if we've already done the same or more, just return answer*/
		if (num == oldnum) {
			return (factors);
		}
		/* num changed; free the old array */
		FREE(factors);
	}
	oldnum = num;		/* remember it for next time */

	CALLOCA(short, factors, num + 1);

	/* find which numbers up to num are primes */
	isprime = findprimes(num);

	/*
	 * For every prime number until "num" is used up, divide it into num
	 * as many times as possible, keeping track of how many times.
	 */
	orignum = num;
	for (n = 2; n <= orignum && num > 1; n++) {
		if (isprime[n] == YES) {
			while (num % n == 0) {
				num /= n;
				factors[n]++;
			}
		}
	}

	return (factors);
}
\f

/* Return the width of the widest note head in the given GRPSYL. */

double
widest_head(gs_p)

struct GRPSYL *gs_p;

{
	double widest;		/* widest note head in the group */
	double thiswidth;	/* width of current note */
	int n;			/* note index */

	widest = 0.0;
	for (n = 0; n < gs_p->nnotes; n++) {
		thiswidth = width(gs_p->notelist[n].headfont,
			(gs_p->notelist[n].notesize == GS_NORMAL ?
			DFLT_SIZE : SMALLSIZE),
			gs_p->notelist[n].headchar);
		if (thiswidth > widest) {
			widest = thiswidth;
		}
	}
	return(widest);
}