Import upstream version 5.3.

[mup] / mup / mup / beaming.c

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

/* functions called at parse time to deal with beaming. */


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


static void subbeam P((struct SSV *ssv_p, RATIONAL outer_time, int obi,
	struct GRPSYL *begin_gs_p, struct GRPSYL *end_gs_p));
static struct GRPSYL *verify_crossbeam P((struct GRPSYL *gs_p,
	struct GRPSYL *other_gs_p, RATIONAL start_time, RATIONAL *end_time_p,
	int staffno, int size));
static void
slopelencheck P((struct GRPSYL *first_p, struct GRPSYL *last_p, char *bmtype));


/* this function will get called whenever a group is not the start or end
 * of a custom beam group. This will fill in the beamloc based on past
 * history. If we were most recently in a custom beam group, we still are.
 * If we weren't before, we aren't now either. The non-custom beaming
 * gets done later after we have collected a whole bar in do_beaming()
 * which is called via do_bar(). */

void
setbeamloc(curr_grp_p, last_grp_p)

struct GRPSYL *curr_grp_p;	/* the group we're working on */
struct GRPSYL *last_grp_p;	/* the last group we did */

{
	if (curr_grp_p->grpvalue == GV_ZERO) {
		/* grace notes don't get handled here */
		curr_grp_p->beamloc = NOITEM;
		return;
	}

	/* if the previous group is a grace group, that doesn't count. Back
	 * up in the list to the first non-grace or beginning of list */
	for (  ; last_grp_p != (struct GRPSYL *) 0
					&& last_grp_p->grpvalue == GV_ZERO;
					last_grp_p = last_grp_p->prev) {
		;
	}

	if (last_grp_p != (struct GRPSYL *) 0) {

		switch (last_grp_p->beamloc) {

		case STARTITEM:
		case INITEM:
			curr_grp_p->beamto = last_grp_p->beamto;
			/* Make sure notes are 8th or shorter. Spaces (which
			 * are allowed in cross-staff beams) can be longer. */
			if (curr_grp_p->basictime < 8) {
				/* At this point, spaces are still
				 * pseudo-pitches, so have to figure out
				 * if this group is really notes */
				int letter;	/* pitch */
				int n;		/* index through notelist */
				for (n = 0; n < curr_grp_p->nnotes; n++) {
					letter = curr_grp_p->notelist[n].letter;
					if ((letter >= 'a' && letter <= 'g') ||
							letter == PP_NO_PITCH) {
						yyerror("beamed notes must be 8th or shorter");
						break;
					}
				}
			}

			/* if previous began beaming, we must be inside now */
			/* if in beam before, we still are */
			curr_grp_p->beamloc = INITEM;
			break;

		case ENDITEM:
		case NOITEM:
		default:
			/* if previous was ending beaming, or
			 * we weren't inside a beam, must be no beam now */
			curr_grp_p->beamloc = NOITEM;
			break;
		}
	}
	else {
		/* nothing specified before, so no beam */
		curr_grp_p->beamloc = NOITEM;
	}
}
\f

/* take a quick jaunt through a GRPSYL list, seeing if custom
 * beaming was already done. If so, return YES, otherwise NO.
 * If there are any non-grace groups with beaming info, there must
 * have been custom beaming. Also, verify that user didn't attempt to
 * custom beam a mixture of normal and cue size notes,
 * or try to put illegal rests or spaces inside a beam.
 * Spaces are only allowed in cross-staff beams, unless user explicitly
 * says to beam across spaces. Rests are also only allowed in beams if
 * the user explicitly states they should be. Rests and spaces cannot be on
 * the ends, and must be eighth note or shorter.
 * We allow beaming together chords that are stemmed to another staff
 * only if all such instances are to the same staff--not some to staff above
 * and others to staff below--because beaming involving 3 staffs at once is
 * just too hard to deal with.
 * Also check that any esbm has at least 2 notes before and after it.
 */

int
has_cust_beaming(grpsyl_p)

struct GRPSYL *grpsyl_p;	/* list of GRPSYLs to check */

{
	int has = NO;
	int size = GS_NORMAL;
	int numnotes = 0;	/* how many notes groups, for esbm check */
	short stemto = CS_SAME;	/* to check for mixed CS_ABOVE/CS_BELOW */
	struct GRPSYL *start_p = 0;	/* first beamed group */

	for (   ; grpsyl_p != (struct GRPSYL *) NULL;
				grpsyl_p = grpsyl_p->next) {

		if ((grpsyl_p->grpvalue != GV_ZERO)
				&& (grpsyl_p->beamloc != NOITEM)) {
			/* have non-grace with beam info set */
			has = YES;

			/* check for size or cross-staff stem mixtures */
			if (grpsyl_p->beamloc == STARTITEM) {
				size = grpsyl_p->grpsize;
				numnotes = 0;
				stemto = CS_SAME;
			}
			/* check for size mixture. But only do non-cross-staff
			 * beams here, because it's a lot easier to do the
			 * cross-staff beam check in chk_crossbeams() */
			else if (grpsyl_p->grpsize != size
					&& grpsyl_p->beamto == CS_SAME) {
				l_yyerror(grpsyl_p->inputfile,
					grpsyl_p->inputlineno,
					"can't beam normal and cue notes together");
			}

			if (grpsyl_p->grpcont != GC_NOTES) {
				if (grpsyl_p->grpcont == GC_REST) {
					if (grpsyl_p->basictime < 8) {
						l_yyerror(grpsyl_p->inputfile,
							grpsyl_p->inputlineno,
							"rests inside a beam must be less than quarter note duration");
					}
					if (grpsyl_p->beamloc != INITEM) {
						l_yyerror(grpsyl_p->inputfile,
							grpsyl_p->inputlineno,
							"beam cannot %s with a rest",
						grpsyl_p->beamloc == STARTITEM ?
						"begin" : "end");
					}
				}
				else if (grpsyl_p->beamto == CS_SAME) {
					if (grpsyl_p->beamloc != INITEM) {
						l_yyerror(grpsyl_p->inputfile,
						grpsyl_p->inputlineno,
						"beam cannot begin or end with a space");
					}
					if (grpsyl_p->basictime < 8) {
						l_yyerror(grpsyl_p->inputfile,
						grpsyl_p->inputlineno,
						"spaces inside a beam must be less than quarter note duration");
					}
				}
			}
			else if (grpsyl_p->grpvalue != GV_ZERO) {
				numnotes++;
			}

			if (grpsyl_p->stemto != CS_SAME) {
				if (stemto != CS_SAME && grpsyl_p->stemto
								!= stemto) {
					l_yyerror(grpsyl_p->inputfile,
					grpsyl_p->inputlineno,
					"beam cannot include chords with stems to both above and below staffs");
				}
				stemto = grpsyl_p->stemto;
			}

			if (grpsyl_p->beamloc == INITEM &&
					IS_STEMLEN_KNOWN(grpsyl_p->stemlen)) {
				l_yyerror(grpsyl_p->inputfile,
					grpsyl_p->inputlineno,
					"stem len specification not allowed inside a beam");
			}
	
			if (grpsyl_p->beamloc == STARTITEM) {
				start_p = grpsyl_p;
			}
			else if (grpsyl_p->beamloc == ENDITEM) {
				if (start_p != 0) {
					slopelencheck(start_p, grpsyl_p, "beam");
					start_p = 0;
				}
			}

			if (grpsyl_p->breakbeam == YES
					&& grpsyl_p->beamto == CS_SAME) {
				if (numnotes < 2) {
					l_warning(grpsyl_p->inputfile,
						grpsyl_p->inputlineno,
						"esbm must be preceeded by at least 2 beamed notes");
					grpsyl_p->breakbeam = NO;
				}
				else {
					struct GRPSYL *g_p;

					/* Check that there are
					 * at least 2 following beamed notes */
					numnotes = 0;
					for (g_p = grpsyl_p->next; g_p != 0;
							g_p = g_p->next) {
						if (g_p->grpcont == GC_NOTES &&
						    g_p->grpvalue != GV_ZERO) {
							numnotes++;
						}
						if (g_p->breakbeam == YES) {
							break;
						}
						if (g_p->beamloc == ENDITEM) {
							break;
						}
					}
					if (numnotes < 2) {
						l_warning(grpsyl_p->inputfile,
							grpsyl_p->inputlineno,
							"esbm must be followed by at least 2 beamed notes");
						grpsyl_p->breakbeam = NO;
					}
					else if (grpsyl_p->grpcont != GC_NOTES) {
						/* User really should have put
						 * the esbm on the preceeding
						 * NOTES group. We'll be nice
						 * and move it for them.
						 */
						grpsyl_p->breakbeam = NO;
						for (g_p = grpsyl_p->prev;
								g_p->grpcont != GC_NOTES;
								g_p = g_p->prev) {
							;
						}
						g_p->breakbeam = YES;
					}
				}
				numnotes = 0;
			}
		}
	}

	return(has);
}
\f

/* beam notes together according to user-specified default beaming style */

void
do_beaming(gs_p, grpsize, staffno, vno)

struct GRPSYL *gs_p;		/* list of GRPSYLs to do beaming on */
int grpsize;			/* GS_NORMAL or GS_SMALL
				 * (grace are handled separately) */
int staffno;
int vno;			/* voice number */

{
	struct SSV *ssv_beaminfo_p;	/* ssv having relevent beam info */
	register int n;			/* index into beamstyle list */
	RATIONAL styletime;		/* accumulated time to beam together */
	RATIONAL tot_time;		/* cumulative grpsyl time */
	struct GRPSYL *first_p;		/* first in beam group */
	struct GRPSYL *last_p;		/* last in beam group */
	int stop;			/* YES if need to stop beaming */
	int beamrests;			/* if to include rests inside beams */
	int beamspaces;			/* if to include spaces inside beams */
	short stemto = CS_SAME;		/* check for mixed CS_ABOVE/CS_BELOW */
	short restart = NO;		/* YES if could start another beam
					 * with current group, even though
					 * it can go with previous */



	debug(4, "do_beaming file=%s line=%d grpsize=%d staff=%d voice=%d",
		gs_p->inputfile, gs_p->inputlineno, grpsize, staffno, vno);

	/* if no default beaming scheme for this voice, then nothing to do--
	 * any custom beaming would have already been done */
	ssv_beaminfo_p = vvpath(staffno, vno, BEAMSTLIST);
	if (ssv_beaminfo_p->nbeam == 0) {
		return;
	}

	/* ok. We may need to do some beaming. Go through the beamstlist and
	 * see if there are any groups to beam together */

	/* initialize */
	/* point to first non-grace group */
	for (  ; gs_p != (struct GRPSYL *) 0 && gs_p->grpcont == GC_NOTES
			&& gs_p->grpvalue == GV_ZERO; gs_p = gs_p->next) {
		;
	}

	/* if no groups, nothing to do */
	if (gs_p == (struct GRPSYL *) 0) {
		return;
	}

	beamrests = vvpath(staffno, vno, BEAMSTLIST)->beamrests;
	beamspaces = vvpath(staffno, vno, BEAMSTLIST)->beamspaces;
	styletime = tot_time = Zero;
	for (n = 0; n < ssv_beaminfo_p->nbeam; n++) {
		styletime = radd(styletime, ssv_beaminfo_p->beamstlist[n]);

		if (GE(tot_time, styletime)) {
			/* we're already past this beamstyle segment */
			continue;
		}

		for (first_p = last_p = 0, stop = NO;
				LT(tot_time, styletime); gs_p = gs_p->next) {

			if (gs_p == 0) {
				/* Must be too few groups in measure.
				 * This error will already have been
				 * reported elsewhere.
				 */
				return;
			}

			/* ignore grace */
			while (gs_p->grpvalue == GV_ZERO) {
				gs_p = gs_p->next;
				if (gs_p == 0) {
					/* Must have tried to end a measure
					 * with grace. Already reported. */
					return;
				}
			}

			tot_time = radd(tot_time, gs_p->fulltime);
			if (GE(tot_time, styletime)) {
				/* This group puts us at or past
				 * the current beamstyle segment */
				stop = YES;
			}

			/* only 8th and shorter get beamed */
			if (gs_p->basictime < 8 || (gs_p->grpcont == GC_SPACE &&
						beamspaces == NO) ) {
				stop = YES;
			}
			else if (gs_p->grpcont == GC_REST && beamrests == NO) {
				stop = YES;
			}
			else if (gs_p->grpsize != grpsize) {
				/*  Wrong size to beam on this call */
				stop = YES;
			}
			else if (gs_p->stemto != CS_SAME && stemto != CS_SAME
					&& gs_p->stemto != stemto) {
				/* We don't allow beaming across three staffs,
				 * so have to stop current beam, but could
				 * possibly beam this group with following
				 * groups, as long as they don't have a
				 * conflicting stemto */
				stop = YES;
				restart = YES;
			}
			else if (gs_p->grpcont == GC_NOTES && 
						LE(tot_time, styletime)) {
				/* found something beam-able */
				if (first_p == 0) {
					first_p = gs_p;
				}
				last_p = gs_p;
			}
			if (gs_p->stemto != CS_SAME) {
				stemto = gs_p->stemto;
			}

			if (stop == YES) {
				if (first_p != 0 && last_p != 0
							&& first_p != last_p) {
					/* Disallow illegal combinations of
					 * slope and stem length */
					slopelencheck(first_p, last_p, "beam");

					/* If there are subbeam groupings,
					 * do those. */
					subbeam(ssv_beaminfo_p,
						rsub(styletime, ssv_beaminfo_p->beamstlist[n]),
						n, first_p, last_p);

					/* mark beginning of beam group */
					first_p->beamloc = STARTITEM;

					/* mark all intermediate groups,
					 * skipping grace */
					for (first_p = first_p->next;
							first_p != last_p;
							first_p = first_p->next) {

						if (first_p->grpvalue
								== GV_ZERO) {
							continue;
						}

						first_p->beamloc = INITEM;

						if (IS_STEMLEN_KNOWN(first_p->stemlen)) {
							l_yyerror(first_p->inputfile, first_p->inputlineno,
							    "stem len specification not allowed inside a beam");
						}
					}

					/* mark the end of the beam group */
					last_p->beamloc = ENDITEM;
				}

				/* Re-init for any more bunches to beam */
				first_p = last_p = 0;
				stop = NO;
				stemto = CS_SAME;
				if (restart == YES) {
					if (gs_p->grpcont == GC_NOTES) {
						first_p = gs_p;
					}
					restart = NO;
				}
			}
		}
	}
}
\f

/* Once a STARTITEM and ENDITEM groups of the regular beamstyle
 * have been identified, go through them to see if there should
 * be subgroups. If so, mark breakbeam = YES on the last group of
 * each subgroup.
 */

static void
subbeam(ssv_p, outer_time, obi, begin_gs_p, end_gs_p)

struct SSV *ssv_p;	/* to get beamstlist and subbeamstlist */
RATIONAL outer_time;	/* Time in measure when outer beam begins */
int obi;		/* outer beam index, subscript into ssv_p->beamstlist */
struct GRPSYL *begin_gs_p;
struct GRPSYL *end_gs_p;

{
	int sbi;	/* sub beam index, subscript of ssv_p->subbeamstlist */
	RATIONAL subgroup_time;	/* duration of items in subbeamstlist */
	RATIONAL tot_time;	/* sum of note groups in subbeaming */
	struct GRPSYL *gs_p;	/* walk through groups */
	struct GRPSYL *last_notegroup_p;/* Most recent GC_NOTES GRPSYL */


	/* Check if more than one beam subgroup
	 * makes up the outer beam grouping. */
	if (ssv_p->nbeam == ssv_p->nsubbeam) {
		/* There are no sub-beam groupings anywhere in the measure */
		return;
	}

	/* Find the subbeamlist entry that matches with the outer beam entry */
	subgroup_time = Zero;
	for (sbi = 0; LT(subgroup_time, outer_time); sbi++) {
		subgroup_time = radd(subgroup_time, ssv_p->subbeamstlist[sbi]);
	}

	if ( EQ(ssv_p->beamstlist[obi], ssv_p->subbeamstlist[sbi]) ) {
		/* Outer and subbeam have the same time duration,
		 * so there aren't any subgroups in this outer beam grouping. */
		return;
	}

	/* There are subgroups inside the outer beam grouping,
	 * so we may need to set one or more breakbeams. */
	subgroup_time = ssv_p->subbeamstlist[sbi];

	/* If beam starts later than the outer beamstyle item begins,
	 * (e.g., if there was a rest at the beginning of the beam time),
	 * we have to count that time as already taken up from the subbeam.
	 */
	for (tot_time = Zero, gs_p = begin_gs_p->prev; gs_p != 0;
							gs_p = gs_p->prev) {
		tot_time = radd(tot_time, gs_p->fulltime);
	}
	tot_time = rsub(tot_time, outer_time);
	last_notegroup_p = 0;
	for (gs_p = begin_gs_p; gs_p != end_gs_p; gs_p = gs_p->next) {

		/* Grace notes are irrelevant */
		if (gs_p->grpvalue == GV_ZERO) {
			continue;
		}

		/* Remember where last note group is, in case we
		 * need to set breakbeam on it. */
		if (gs_p->grpcont == GC_NOTES) {
			last_notegroup_p = gs_p;
		}

		/* Add up group time values until the total equals
		 * or exceeds that of the subgroup. */
		tot_time = radd(tot_time, gs_p->fulltime);
		if (LT(tot_time, subgroup_time)) {
			/* not far enough yet */
			continue;
		}
	
		/* If the value exceeds, there is a note spanning the
		 * subgroup boundary, so just ignore the subgrouping. */
		if (GT(tot_time, subgroup_time)) {
			tot_time = rsub(tot_time, subgroup_time);
			subgroup_time = ssv_p->subbeamstlist[++sbi];
			if (gs_p->grpcont != GC_NOTES) {
				last_notegroup_p = 0;
			}
		}

		else {
			/* A group ends right at the subbeam boundary. 
			 * Set breakbeam on last group, if there was one. 
			 */
			if (last_notegroup_p != 0) {
				last_notegroup_p->breakbeam = YES;
			}

			/* The current subbeam is finished.
			 * Move on to the next subbeam, if there is one. */
			if (++sbi < ssv_p->nsubbeam) {
				subgroup_time = ssv_p->subbeamstlist[sbi];
				/* Since we know the subbeam we just
				 * finished ended exactly
				 * at the subbeam boundary,
				 * we set to time taken up so far
				 * by the new subbeam to zero. 
				 */
				tot_time = Zero;
				last_notegroup_p = 0;
			}
		}
	}
}
\f

/* alt groups must always have beamloc set, so fix them */

void
set_alt_beams(gs_p)

struct GRPSYL *gs_p;	/* a measure's worth of GRPSYLs for a voice */

{
	struct GRPSYL *other_gs_p;	/* group on other end of alt pair */


	debug(4, "set_alt_beams file=%s line=%d",
			gs_p->inputfile, gs_p->inputlineno);

	/* walk through the list, fixing any alt groups */
	for (   ; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {

		/* check if is an alt pair */
		if (gs_p->slash_alt < 0) {

			if (gs_p->next == (struct GRPSYL *) 0) {
				/* no second group in alt, will be flagged
				 * elsewhere */
				continue;
			}

			/* set the pair as a beam group */
			gs_p->beamloc = STARTITEM;
			gs_p->next->beamloc = ENDITEM;

			slopelencheck(gs_p, gs_p->next, "alt");

			/* middle phase wants to have both notes in an alt group
			 * have their alt field set, so do that */
			gs_p->next->slash_alt = gs_p->slash_alt;

			/* adjust preceeding and following groups if necessary.
			 * If was already in a beam group, split off the other
			 * parts into their own groups or put flags on the
			 * extras if they are down to one group */

			/* find previous normal group if any and adjust */
			for (other_gs_p = gs_p->prev;
					other_gs_p != (struct GRPSYL *) 0;
					other_gs_p = other_gs_p->prev) {

				if (other_gs_p->grpvalue != GV_ZERO) {
					if (other_gs_p->grpcont == GC_REST) {
						other_gs_p->beamloc = NOITEM;
					}
					else {
						break;
					}
				}
			}

			if (other_gs_p != (struct GRPSYL *) 0) {

				switch (other_gs_p->beamloc) {

				case INITEM:
					other_gs_p->beamloc = ENDITEM;
					break;

				case STARTITEM:
					other_gs_p->beamloc = NOITEM;
					break;

				default:
					break;
				}
			}
					
			/* now do the same for the following group */
			for (other_gs_p = gs_p->next->next;
					other_gs_p != (struct GRPSYL *) 0;
					other_gs_p = other_gs_p->next) {

				if (other_gs_p->grpvalue != GV_ZERO) {
					if (other_gs_p->grpcont == GC_REST) {
						other_gs_p->beamloc = NOITEM;
					}
					else {
						break;
					}
				}
			}

			if (other_gs_p != (struct GRPSYL *) 0) {

				switch (other_gs_p->beamloc) {

				case INITEM:
					other_gs_p->beamloc = STARTITEM;
					break;

				case ENDITEM:
					other_gs_p->beamloc = NOITEM;
					break;

				default:
					break;
				}
			}

			/* skip over the second in the pair */
			gs_p = gs_p->next;
		}
	}
}
\f

/* Given a list of GRPSYLs on a visible voice
 * having "bm with staff below" do all the error checking.
 * This list of groups has to be for the bottom visible voice
 * for the duration of the beam.
 * There has to be a set of groups on the top non-space visible
 * voice of the first visible staff below,
 * which starts a "bm with staff above" at exactly
 * the same time value. The ebm values also have to match. At every
 * point inside the beam, one voice must have notes and the other voice
 * must have spaces.
 *
 * Have to be careful in this function,
 * because the gs_p->staffno and gs_p->vno may not be filled in yet,
 * so have to use the staffno from the STAFF struct, and get vno from the
 * first gs_p, which the caller is supposed to have filled in correctly.
 *
 * Returns the staff number of the staff containing the matching
 * "bm with staff above" or -1 if no such staff was found.
 */

int
chk_crossbeam(gs_p, mll_p)

struct GRPSYL *gs_p;	/* first group in above voice of cross staff beam */
struct MAINLL *mll_p;	/* gs_p hangs off of here */

{
	struct GRPSYL *g_p;		/* for walking through group list */
	struct GRPSYL *other_p;		/* group on other staff */
	struct MAINLL *assoc_mll_p;	/* other staff hangs off of here */
	struct GRPSYL *assoc_grps_p;	/* the measure-worth of groups in
					 * the voice being beamed to */
	RATIONAL start_time, end_time;	/* of the above voice */
	RATIONAL other_start, other_end;/* time of groups on below staff */
	int user_specified_stem_len;	/* YES or NO */
	int size = GS_NORMAL;
	int assoc_vno;			/* voice number on below staff */
	struct STAFF *staff_p;
	int staffno;
	int vno;


	/* only the first gs_p is guaranteed to have the right vno at this
	 * point, so save that. */
	vno = gs_p->vno;
	staff_p = mll_p->u.staff_p;
	staffno = staff_p->staffno;

	/* find where in the measure the beam begins, by adding up the
	 * time values of all the groups prior to the first beamed group */
	for (start_time = Zero, g_p = gs_p->prev; g_p != (struct GRPSYL *) 0;
					g_p = g_p->prev) {
		start_time = radd(start_time, g_p->fulltime);
	}

	/* find how long the beam lasts. Also see if there are any small
	 * groups */
	for (end_time = start_time, g_p = gs_p; g_p != (struct GRPSYL *) 0;
					g_p = g_p->next) {
		/* accumulate the time */
		end_time = radd(end_time, g_p->fulltime);

		/* check for small groups */
		if (g_p->grpcont == GC_NOTES && g_p->grpsize == GS_SMALL
						&& g_p->grpvalue != GV_ZERO) {
			size= GS_SMALL;
		}

		/* end of the beam? */
		if (g_p->beamloc == ENDITEM && g_p->grpvalue != GV_ZERO) {
			break;
		}
	}
	if (g_p == (struct GRPSYL *) 0) {
		/* maybe this should be silent, since another error message
		 * should already be printed, but this will point out that
		 * the problem was on a cross-staff beam */
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
					"can't find end of cross-staff beam");
		return(-1);
	}

	/* Make sure this is the bottom voice of the above staff.
	 * If it's voice 2 (subscript 1) then it is for sure.
	 * Otherwise, have to make sure the second and third voices, if any,
	 * have all spaces for the duration of the cross-staff beam */
	if (vno != 1) {
		/* If voice 2 is visible and not all spaces,
		 * or if we are working on voice 1 while voice 3 is
		 * visible and not all space, there is a problem. */
		if (vvpath(staffno, 2, VISIBLE)->visible == YES &&
				hasspace(staff_p->groups_p[1], start_time,
				end_time) == NO || (vno == 0 &&
				vvpath(staffno, 3, VISIBLE)->visible == YES &&
				hasspace(mll_p->u.staff_p->groups_p[2],
				start_time, end_time) == NO)) {
			l_yyerror(gs_p->inputfile, gs_p->inputlineno,
				"cross-staff beam must be from bottom voice of staff %d",
				mll_p->u.staff_p->staffno);
			return(-1);
		}
	}

	/* Find the associated voice, and the associated bm group
	 * in that voice. First find the next visible staff */
	for (assoc_mll_p = mll_p->next;   ; assoc_mll_p = assoc_mll_p->next) {
		if (assoc_mll_p == (struct MAINLL *) 0 ||
						assoc_mll_p->str != S_STAFF) {
			l_yyerror(gs_p->inputfile, gs_p->inputlineno,
					"no visible staff below to beam with");
			return(-1);
		}

		if (svpath(assoc_mll_p->u.staff_p->staffno, VISIBLE)->visible
							== YES) {
			/* found the right staff */
			break;
		}
	}

	/* Associated voice is probably voice 1 of the below staff.
	 * But there is a slight possibility it is voice 2, or even voice 3.
	 * Skip over voices that are all spaces for the duration of the beam.
	 * Since voice 3 is the "middle" voice, we check 1, then 3, then 2.
	 */
	if (vvpath(staffno, 1, VISIBLE)->visible == YES &&
			hasspace(assoc_mll_p->u.staff_p->groups_p[0],
			start_time, end_time) == NO) {
		assoc_grps_p = assoc_mll_p->u.staff_p->groups_p[0];
		assoc_vno = 0;
	}
	else if (vvpath(staffno, 3, VISIBLE)->visible == YES &&
			hasspace(assoc_mll_p->u.staff_p->groups_p[2],
			start_time, end_time) == NO) {
		assoc_grps_p = assoc_mll_p->u.staff_p->groups_p[2];
		assoc_vno = 2;
	}
	else if (vvpath(staffno, 2, VISIBLE)->visible == YES &&
			hasspace(assoc_mll_p->u.staff_p->groups_p[1],
			start_time, end_time) == NO) {
		assoc_grps_p = assoc_mll_p->u.staff_p->groups_p[1];
		assoc_vno = 1;
	}
	else {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
				"cross-staff beam has no notes on staff %d",
				assoc_mll_p->u.staff_p->staffno);
		return(-1);
	}

	/* Tab staffs can't be involved in cross-staff beaming */
	if (is_tab_staff(mll_p->u.staff_p->staffno) ||
			is_tab_staff(assoc_mll_p->u.staff_p->staffno)) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
				"cross-staff beaming not allowed on tab staff");
		return(-1);
	}

	/* We don't allow the different staffs to have different staffscale
	 * values: it doesn't really make much sense to allow it, and avoids
	 * all the issues like how wide to make the beams.
	 */
	if (svpath(mll_p->u.staff_p->staffno, STAFFSCALE)->staffscale !=
			svpath(assoc_mll_p->u.staff_p->staffno,
			STAFFSCALE)->staffscale) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"staffs involved with cross-staff beams must have identical staffscale values");
		/* We did find which to associate with, even though
		 * its staffscale was wrong. */
		return(assoc_mll_p->u.staff_p->staffno);
	}

	/* find the group that ought to be the "bm with staff above" group, by
	 * going that far time-wise into the measure on the associated voice */
	for (other_start = Zero, other_p = assoc_grps_p;
				other_p != (struct GRPSYL *) 0;
				other_p = other_p->next) {

		if (GT(other_start, start_time)) {
			/* too far. pretend to be at end of list so we
			 * and fall out of loop to print the error message
			 * for this case */
			other_p = (struct GRPSYL *) 0;
			break;
		}

		if (EQ(other_start, start_time)) {
			/* found it! */
			break;
		}

		if (other_p->grpvalue == GV_ZERO) {
			continue;
		}

		/* have to keep going. Keep track of how far we are in time */
		other_start = radd(other_start, other_p->fulltime);
	}

	/* skip past any grace groups */
	while (other_p != 0 && other_p->grpvalue == GV_ZERO) {
		other_p = other_p->next;
	}

	/* If we didn't find a voice below, or that voice's group
	 * isn't the start of a beam with above, there is a problem.
	 * In the second case, maybe user really meant to beam with some
	 * lower voice, but that would collide, which we don't allow.
	 */
	if (other_p == (struct GRPSYL *) 0 || other_p->beamloc != STARTITEM
					|| other_p->beamto != CS_ABOVE) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"'bm with staff below' has no matching 'bm with staff above' (may be missing, invisible, or on wrong voice)");
		return(assoc_mll_p->u.staff_p->staffno);
	}

	/* check if user specified a stem length on the first group */
	if (IS_STEMLEN_KNOWN(gs_p->stemlen)
				|| IS_STEMLEN_KNOWN(other_p->stemlen)) {
		user_specified_stem_len = YES;
	}
	else {
		user_specified_stem_len = NO;
	}

	/* go through the two voices. For each note group, verify that
	 * the other voice has space during that time period. Do the "other"
	 * staff first, because in a previous version of this function it
	 * had to be done in that order to avoid possible null pointer
	 * dereference. Now things have changed, so that doesn't matter
	 * any more, but I don't want to change the order, to make sure I
	 * don't break something.
	 */
	other_p = verify_crossbeam(other_p,
			mll_p->u.staff_p->groups_p[vno], start_time,
			&other_end, assoc_mll_p->u.staff_p->staffno, size);
	gs_p = verify_crossbeam(gs_p, assoc_grps_p, start_time, &end_time,
			mll_p->u.staff_p->staffno, size);

	/* we should be pointing to the ebm group for each staff,
	 * unless of course, something went wrong, like user didn't
	 * specify an ebm */
	if (gs_p == (struct GRPSYL *) 0 || other_p == (struct GRPSYL *) 0) {
		/* maybe this should be silent, since another error message
		 * should already be printed, but this will point out that
		 * the problem was on a cross-staff beam */
		l_yyerror(assoc_grps_p->inputfile, assoc_grps_p->inputlineno,
			"failed to find ebm for cross-staff beam");
		return(assoc_mll_p->u.staff_p->staffno);
	}

	if (NE(end_time, other_end)) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"ebm not at same time in measure for both voices of cross-staff beam");
	}

	/* Disallow illegal combinations of slope and stem length */
	slopelencheck(gs_p, other_p, "beam");

	return(assoc_mll_p->u.staff_p->staffno);
}
\f

/* Given the first group of a cross-staff beam, and the beginning of the
 * list of GRPSYLs in the associated voice (the voice beamed to), and the
 * time into the measure where the beam starts, check each group. Verify
 * that each GC_NOTES group has GC_SPACE in the other voice and vice-versa.
 * Also check that all note groups are the same size, and mark the spaces
 * as the correct size so that everything in the beam has the same size.
 * Return a pointer to the last group in the beam (null if something goes
 * wrong). Also, return the time into the measure of the end of the beam,
 * via the end_time_p pointer.
 */

static struct GRPSYL *
verify_crossbeam(gs_p, other_gs_p, start_time, end_time_p, staffno, size)

struct GRPSYL *gs_p;	/* first group in list to be checked */
struct GRPSYL *other_gs_p; /* the groups_p of the associated voice */
RATIONAL start_time;	/* when the beam begins */
RATIONAL *end_time_p;	/* time through end of beam will be returned here */
int staffno;
int size;		/* GS_NORMAL or GS_SMALL */

{
	RATIONAL end_time;
	int has_at_least_1_note_group = NO;


	/* go through each group in the beam */
	for (  ; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {

		/* skip over any grace groups */
		if (gs_p->grpvalue == GV_ZERO) {
			continue;
		}

		/* find the end time of the group, for passing to hasspace() */
		end_time = radd(start_time, gs_p->fulltime);

		/* if notes, other voice must have space */
		if (gs_p->grpcont == GC_NOTES) {
			if (hasspace(other_gs_p, start_time, end_time) == NO) {
				l_yyerror(gs_p->inputfile, gs_p->inputlineno,
					"cross-staff beam must always have notes in one voice and space in the other voice");
				return (struct GRPSYL *) 0;
			}
			has_at_least_1_note_group = YES;
			if (gs_p->grpsize != size) {
				l_yyerror(gs_p->inputfile, gs_p->inputlineno,
				"can't mix normal and cue size chords in cross-staff beam");
			}
		}

		/* conversely, if space, other voice must not have space */
		else if (gs_p->grpcont == GC_SPACE) {
			struct GRPSYL *g_p;
			RATIONAL t;
			int oldcont = GC_SPACE;

			/* This is somewhat like hasspace() except that checks
			 * that the entire duration is space. Here we need
			 * to check if there is space at least somewhere during
			 * the time period. If so, user error.
			 */
			for (g_p = other_gs_p, t = Zero; LT(t, start_time);
							g_p = g_p->next) {
				if (g_p->grpvalue == GV_ZERO) {
					continue;
				}
				t = radd(t, g_p->fulltime);
				oldcont = g_p->grpcont;
			}
			if (GT(t, start_time) && oldcont == GC_SPACE) {
				/* group spilling into this time is space */
				l_yyerror(gs_p->inputfile, gs_p->inputlineno,
					"cross-staff beam must always have notes in one voice and space in the other voice");
				return (struct GRPSYL *) 0;
			}
			for (   ; g_p != 0 && LT(t, end_time); g_p = g_p->next) {
				if (g_p->grpvalue == GV_ZERO) {
					continue;
				}
				if (g_p->grpcont == GC_SPACE) {
					l_yyerror(gs_p->inputfile, gs_p->inputlineno,
						"cross-staff beam must always have notes in one voice and space in the other voice");
					return (struct GRPSYL *) 0;
				}
				t = radd(t, g_p->fulltime);
			}

			/* mark size of spaces. Normally space can't be cue				 * size, but in this case, it makes it easier for later
			 * code (in print phrase at least) if everything in the
			 * beam--even spaces--is marked as cue size */
			gs_p->grpsize = size;
		}

		/* esbm is not currently allowed on cross-staff beams.
		 * It would much more complicated than normal beams,
		 * because the "primary" beam might perhaps best be the top,
		 * the bottom, or the middle, depending on where the notes are.
		 * Placement and print phase would have to know about that,
		 * so that stems could be adjusted properly,
		 * and beams drawn in the right places.
		 */
		if (gs_p->breakbeam == YES) {
			l_warning(gs_p->inputfile, gs_p->inputlineno,
					"esbm is not supported on cross-staff beams; being ignored");
			gs_p->breakbeam = NO;
		}

		/* see if we reached the end of the beam */
		if (gs_p->beamloc == ENDITEM) {
			*end_time_p = end_time;
			if (has_at_least_1_note_group == NO) {
				l_yyerror(gs_p->inputfile, gs_p->inputlineno,
					"cross-staff beam has no notes on staff %d",
					staffno);
			}

			return(gs_p);
		}

		/* arrange for next time through the loop, by moving the
		 * start_time to the next group */
		start_time = end_time;
	}

	/* failed to find an ebm */
	return (struct GRPSYL *) 0;
}
\f

/* User is not allowed to specify length on both ends of a beam along with
 * a slope, because they could becontradictory. */

static void
slopelencheck(first_p, last_p, bmtype)

struct GRPSYL *first_p;		/* first beamed group */
struct GRPSYL *last_p;		/* last beamed group */
char *bmtype;			/* "beam" or "alt" */

{
	if (IS_STEMLEN_KNOWN(first_p->stemlen) == YES &&
			IS_STEMLEN_KNOWN(last_p->stemlen) == YES &&
			fabs(first_p->beamslope - NOBEAMANGLE) > 0.001) {
		l_yyerror(last_p->inputfile, last_p->inputlineno,
			"can't specify both end stem lengths and slope for %s",
			bmtype);
	}
}