Import upstream version 5.3.

[mup] / mup / mup / mkchords.c

/* Copyright (c) 1995, 1996, 1997, 1998, 2002, 2003, 2004, 2006
 * by Arkkra Enterprises */
/* All rights reserved */
/*
 * Name:	mkchords.c
 *
 * Description:	This file contains functions for creating CHORD linked lists
 *		and erasing invisible voices.
 */

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


static void swingmidi P((void));
static struct GRPSYL *voicevis P((struct GRPSYL *gs_p));
static void combine_voices P((void));
static void chkhand1 P((struct GRPSYL *gs1_p, struct MAINLL *staffmll_p));
static int chk2groups P((struct GRPSYL *hi_p, struct GRPSYL *lo_p,
		struct MAINLL *mll_p, int qual));
static void chkhand2 P((struct GRPSYL *gs1_p, struct MAINLL *staffmll_p));
static int chk2neighbors P((struct GRPSYL *first_p, struct GRPSYL *second_p,
		struct GRPSYL *gs1_p, struct MAINLL *mll_p));
static void dohand P((struct GRPSYL *gs1_p, struct MAINLL *staffmll_p));
static void comb2groups P((struct GRPSYL *dest_p, struct GRPSYL *src_p,
		struct MAINLL *mll_p));
static void addsrc2dest P((struct GRPSYL *dest_p, struct GRPSYL *src_p));
static int setgrpptrs P((struct GRPSYL *gs1_p, struct GRPSYL *v_p[]));
static int hastieslur P((struct GRPSYL *gs_p));
\f
/*
 * Name:        makechords()
 *
 * Abstract:    Set up the linked lists of chords.
 *
 * Returns:     void
 *
 * Description: This function scans through the main linked list looking
 *		for STAFF structures.  It joins the GRPSYL structures in
 *		the lists that they head, into perpendicular linked lists,
 *		allocating a CHORD to head each of these.  It also links
 *		the CHORDs for each measure together into a linked list.
 *
 *		While doing the above, it also calls voicevis() to check if a
 *		voice should be invisible, and if so changes it to a measure
 *		space.  It also applies the swingunit and voicecombine
 *		parameters.
 */


void
makechords()

{
	struct MAINLL *mainll_p;	/* point at item in main linked list */
	struct MAINLL *mainch_p;	/* for headcell of a chord list */

	RATIONAL *vtime;		/* cum. time of each voice and verse */
	struct GRPSYL **grpsyl_p;	/* pointers along GRPSYL lists */
	struct STAFF *staff_p;		/* point at a staff structure */

	RATIONAL mintime;		/* the minimum vtime */
	register int num;		/* no. of visible voices/verses */
	register int v;			/* index into grpsyl_p[] */
	struct CHORD *ch_p;		/* pointer to current chord */
	struct CHORD *och_p;		/* pointer to old chord */
	struct GRPSYL *gs_p;		/* pointer to current group/syllable */
	int n;				/* loop variable */
	int firstgs;			/* flag for first group/syllable */
	int quit;			/* flag for being done */


	debug(16, "makechords");
	/*
	 * If we are generating MIDI, we may need to change lengths (fulltimes)
	 * of groups.  This has to be done now, before we link groups together
	 * into chords.
	 */
	if (Doing_MIDI == YES) {
		swingmidi();
	}

	gs_p = 0;		/* keep lint happy; will be set before used */

	/* malloc enough of these for all voices and verses */
	MALLOC(rational, vtime, MAXSTAFFS * (MAXVOICES + Maxverses));
	MALLOC(GRPSYL *, grpsyl_p, MAXSTAFFS * (MAXVOICES + Maxverses));

	mainll_p = Mainllhc_p;		/* point at first thing in main LL */

	initstructs();			/* clean out old SSV info */

	/*
	 * Loop once for each measure in the input.
	 */
	for (;;) {
		num = 0;		/* number of linked lists in measure */

		/*
		 * Look for the first structure in this measure that points off
		 * to a linked list of groups/syllables.  If we hit the end of
		 * the main linked list, we're all done, so break out.
		 */
		while (mainll_p != 0 && mainll_p->str != S_STAFF) {
			if (mainll_p->str == S_SSV)
				asgnssv(mainll_p->u.ssv_p);
			mainll_p = mainll_p->next;
		}

		if (mainll_p == 0) {
			FREE(vtime);
			FREE(grpsyl_p);
			break;
		}

		/*
		 * We've found another measure with STAFF in it.  Allocate
		 * a chord headcell for this measure, and put it in the
		 * main linked list.
		 */
		mainch_p = newMAINLLstruct(S_CHHEAD, 0);
		insertMAINLL(mainch_p, mainll_p->prev);

		/*
		 * Look for the last STAFF structure in the measure.  While
		 * doing this, point at first element of all the group/syllable
		 * linked lists, and keep count of them.  Ignore invisible
		 * staffs.  Skip over any grace groups.
		 */
		while (mainll_p != 0 && mainll_p->str == S_STAFF) {
			staff_p = mainll_p->u.staff_p;

			if (staff_p->visible == YES) {

				/* do all the voices on this staff */
				for (n = 0; n < MAXVOICES &&
				staff_p->groups_p[n] != 0; n++) {
					/*
					 * Zap voice if invisible.  Set both
					 * of these to point at the first
					 * GRPSYL, which will be a new one if
					 * we zapped it.
					 */
					grpsyl_p[num] = staff_p->groups_p[n] =
					voicevis(staff_p->groups_p[n]);

					/* skip leading grace groups */
					while (grpsyl_p[num] != 0 &&
					grpsyl_p[num]->grpvalue == GV_ZERO)
						grpsyl_p[num] = grpsyl_p[num]->next;
					if (grpsyl_p[num] == 0)
						pfatal("nothing but grace groups found");
					num++;
				}

				/* do all the verses on this staff */
				for (n = 0; n < staff_p->nsyllists; n++)
					grpsyl_p[num++] = staff_p->syls_p[n];
			}
			mainll_p = mainll_p->next;
		}

		/*
		 * Set up the first chord from the first note in each
		 * voice/verse.  Its linked list of GRPSYLs will include
		 * the first GRPSYL in every linked list off of a visible
		 * STAFF.
		 */
		MALLOC(CHORD, ch_p, 1);
		mainch_p->u.chhead_p->ch_p = ch_p; /* point at first chord */
		ch_p->ch_p = 0;		/* only member on list so far */
		ch_p->starttime = Zero; /* start time = any voice */

		/* point headcell at first and set its first group's time */
		ch_p->gs_p = grpsyl_p[0];
		vtime[0] = grpsyl_p[0]->fulltime;

		/* for each remaining one, point prev one at it & set time */
		for (v = 1; v < num; v++) {
			grpsyl_p[v-1]->gs_p = grpsyl_p[v];
			vtime[v] = grpsyl_p[v]->fulltime;
		}
		grpsyl_p[num-1]->gs_p = 0;	/* terminate linked list */

		/* point at second GRPSYL in each voice/verse, if any */
		for (v = 0; v < num; v++)
			grpsyl_p[v] = grpsyl_p[v]->next;

		/*
		 * Loop until groups/syllables in the voices/verses are used
		 * up.  Form a chord for each time at which any voice/verse
		 * has a GRPSYL structure, though ignore grace groups.
		 */
		for (;;) {
			/*
			 * If every GRPSYL currently pointed at by a grpsyl_p[]
			 * is the last in its list (the measure), there are no
			 * more chords in this measure, and quit will remain
			 * YES.
			 */
			quit = YES;		/* first assume "quit" */
			for (v = 0; v < num; v++) {
				/* find next item (if any) not a grace group */
				while (grpsyl_p[v] != 0 &&
				       grpsyl_p[v]->grpsyl == GS_GROUP &&
				       grpsyl_p[v]->grpvalue == GV_ZERO) {

					grpsyl_p[v] = grpsyl_p[v]->next;
				}

				/* check if voice/verse has another item */
				if (grpsyl_p[v] != 0) {
					quit = NO; /* yes, so don't quit yet */
				}
			}

			/* if time to quit, skip rest of loop, and get out */
			if (quit == YES)
				break;

			/*
			 * At least one voice/verse has another note in it.
			 * Find the earliest time at which something changes.
			 */
			mintime = vtime[0];
			for (v = 1; v < num; v++)
				if (LT(vtime[v], mintime))
					mintime = vtime[v];

			/* allocate memory for another chord */
			och_p = ch_p;	/* remember where previous chord is */
			MALLOC(CHORD, ch_p, 1);
			och_p->ch_p = ch_p;	/* point previous chord at it*/
			ch_p->ch_p = 0;		/* terminate in case last */

			ch_p->starttime = mintime; /* starting time for chord*/

			/*
			 * Form a new linked list.  The head cell is the new
			 * chord, and the list connects it to all the groups/
			 * syllables that start at this time.
			 */
			firstgs = YES;
			for (v = 0; v < num; v++) {
				if (EQ(vtime[v], mintime)) {
					/*
					 * This voice/verse has a grpsyl at
					 * this time.  Make the previous one
					 * point at it, set its pointer to 0
					 * in case it turns out to be the last,
					 * and add its length to vtime[v].
					 */
					if (firstgs == YES) {
						/* point headcell at first */
						ch_p->gs_p = grpsyl_p[v];
						firstgs = NO;
					} else {
						/* point previous one at ours*/
						gs_p->gs_p = grpsyl_p[v];
					}

					/* set gs_p to point at our new one */
					gs_p = grpsyl_p[v];

					vtime[v] = radd(vtime[v],
							gs_p->fulltime);

					/* get next GRPSYL in voice/verse */
					grpsyl_p[v] = gs_p->next;
				}
			}

			gs_p->gs_p = 0;		/* terminate linked list */
		}

		/*
		 * Set the duration of each chord in this measure.  It's the
		 * next chord's start time minus this chord's start time.
		 * But for the last chord, it's the time signature minus
		 * this chord's start time.  Also set pseudodur, which is a
		 * function of the duration.  The amount of width the chord
		 * "deserves" to be allocated is proportional to pseudodur.
		 */
		for (ch_p = mainch_p->u.chhead_p->ch_p; ch_p->ch_p != 0;
				ch_p = ch_p->ch_p) {
			ch_p->duration = rsub(ch_p->ch_p->starttime,
						ch_p->starttime);
			ch_p->pseudodur = pow(RAT2FLOAT(ch_p->duration),
						Score.packexp);
		}
		ch_p->duration = rsub(Score.time, ch_p->starttime);
		ch_p->pseudodur = pow(RAT2FLOAT(ch_p->duration), Score.packexp);
	}

	/* if voicecombine parm was ever set, combine voices if possible */
	if (Vcombused == YES) {
		combine_voices();
	}
}
\f
/*
 * Name:	swingmidi()
 *
 * Abstract:	Alter groups' time to implement the "swingunit" parameter.
 *
 * Returns:	void
 *
 * Description:	This function loops through every GRPSYL in every voice,
 *		adjusting their fulltime so that they will start and end at
 *		different times, if necessary, to follow the "swingunit" parm.
 *		Each measure is divided into durations of "swingunit", starting
 *		at the beginning.  (Usually the timesig divided by swingunit
 *		will be an integer, but if not, the last piece will be shorter.)
 *		The time where one group ends and the next group starts will be
 *		altered in either of these two circumstances:
 *		1. The current boundary time is halfway into a swingunit, and
 *		   each group is at least half a swingunit long.
 *		2. The current boundary time is 3/4 of the way into a swingunit,
 *		   and the first group is at least 3/4 of a swingunit long, and
 *		   and the second group is at least 1/4 of a swingunit long.
 *		In both of these cases, the fulltimes are altered so that the
 *		meeting point is 2/3 of the way into the swingunit.
 */

void
swingmidi()
{
	struct MAINLL *mainll_p;	/* point along main linked list */
	struct GRPSYL *gs_p;		/* point along a GRPSYL list */
	struct GRPSYL *prev_p;		/* the GRPSYL before gs_p */
	int vidx;			/* voice index, 0 to MAXVOICES-1 */
	RATIONAL quot;			/* quotient */
	RATIONAL swingunit;		/* from SSV */
	RATIONAL starttime;		/* offset into measure of gs_p */
	RATIONAL halfswing;		/* swingunit/2 */
	RATIONAL sixthswing;		/* swingunit/6 */
	RATIONAL twelfthswing;		/* swingunit/12 */
	RATIONAL threefourthsswing;	/* 3/4 * swingunit */
	RATIONAL onefourthswing;	/* 1/4 * swingunit */
	static RATIONAL six = {6,1};
	static RATIONAL twelve = {12,1};


	initstructs();

	for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {

		switch (mainll_p->str) {
		case S_SSV:
			/* need to keep swingunit up to date */
			asgnssv(mainll_p->u.ssv_p);
			continue;
		case S_STAFF:
			break;	/* break out and handle this staff */
		default:
			continue;
		}

		/* loop through every voice on this staff */
		for (vidx = 0; vidx < MAXVOICES; vidx++) {

			swingunit = vvpath(mainll_p->u.staff_p->staffno,
					vidx + 1, SWINGUNIT)->swingunit;

			/* skip this voice if swingunit was not set */
			if (EQ(swingunit, Zero)) {
				continue;
			}

			/* various rationals we will need in the loop below */
			halfswing = rdiv(swingunit, Two);
			threefourthsswing = rmul(swingunit, Three_fourths);
			onefourthswing = rmul(swingunit, One_fourth);
			sixthswing = rdiv(swingunit, six);
			twelfthswing = rdiv(swingunit, twelve);

			/* accumulate starttime */
			starttime = Zero;

			/* for lint; we'll never really check it when it's 0 */
			prev_p = 0;

			/* find first nongrace group in voice (0 if none) */
			gs_p = mainll_p->u.staff_p->groups_p[vidx];
			gs_p = gs_p != 0 && gs_p->grpvalue == GV_ZERO ?
					nextnongrace(gs_p) : gs_p;

			/* loop through every nongrace group in this voice */
			for ( ; gs_p != 0; gs_p = nextnongrace(gs_p)) {

				quot = rdiv(starttime, swingunit);

				/* set starttime for the following group here
				 * because we may alter fulltime below */
				starttime = radd(starttime, gs_p->fulltime);

				/* handle case 1 (see prolog above) */
				if (quot.d == 2 &&
				    GE(gs_p->fulltime, halfswing) &&
				    GE(prev_p->fulltime, halfswing)) {

					prev_p->fulltime = radd(
						prev_p->fulltime, sixthswing);
					gs_p->fulltime = rsub(
						gs_p->fulltime, sixthswing);
				}

				/* handle case 2 (see prolog above) */
				if (quot.d == 4 && quot.n % 4 == 3 &&
				    GE(gs_p->fulltime, onefourthswing) &&
				    GE(prev_p->fulltime, threefourthsswing)) {

					prev_p->fulltime = rsub(
						prev_p->fulltime, twelfthswing);
					gs_p->fulltime = radd(
						gs_p->fulltime, twelfthswing);
				}

				prev_p = gs_p;
			}
		}
	}
}
\f
/*
 * Name:        voicevis()
 *
 * Abstract:    If this voice is to be invisible, make it a measure space.
 *
 * Returns:     pointer to first GRPSYL; this equals the input pointer if the
 *		voice is visible, else it points at the new measure space GRPSYL
 *
 * Description: This function finds out if the given voice is supposed to be
 *		invisible this measure.  If so, it throws away the current
 *		GRPSYL list, replacing it with a single GRPSYL that is a
 *		measure space.  See the big comment in svpath() in ssv.c.
 */


static struct GRPSYL *
voicevis(gs_p)

struct GRPSYL *gs_p;		/* first GRPSYL in this voice's linked list */

{
	struct GRPSYL *ngs_p;	/* pointer to the new GRPSYL */


	/*
	 * At this point we know that the command line -s option allows this
	 * staff to be printed, and in fact this staff will be printed, because
	 * at least one of its voice(s) is supposed to be.  (We know this
	 * because where we were called from, staff_p->visible == YES, and that
	 * was set by calling svpath().)  If the staff weren't being printed,
	 * we wouldn't need to bother wiping out its invisible voice(s).
	 */

	/*
	 * This voice must be changed to a measure space if the -s option says
	 * it should be invisible, or if the SSVs say so.  The vvpath function
	 * checks both things.
	 */
	if (vvpath(gs_p->staffno, gs_p->vno, VISIBLE)->visible == NO) {

		/*
		 * Allocate a new GRPSYL and make it a measure space, with the
		 * same inputlineno etc. as the first in the current list.
		 */
		ngs_p = newGRPSYL(GS_GROUP);

		ngs_p->inputlineno = gs_p->inputlineno;
		ngs_p->inputfile = gs_p->inputfile;
		ngs_p->staffno = gs_p->staffno;
		ngs_p->vno = gs_p->vno;
		ngs_p->grpsyl = GS_GROUP;
		ngs_p->is_meas = YES;
		ngs_p->basictime = -1;

		/* in one compiler the following had to be done separately */
		/* like this, because it couldn't do the structure assignment */
		ngs_p->fulltime.n = Score.time.n;
		ngs_p->fulltime.d = Score.time.d;

		ngs_p->grpcont = GC_SPACE;
		ngs_p->prev = 0;
		ngs_p->next = 0;
		ngs_p->gs_p = 0;

		/* throw away the old GRPSYL list */
		free_grpsyls(gs_p);

		return (ngs_p);	/* ret pointer to the measure space */
	}

	return (gs_p);	/* ret pointer to the original, unchanged GRPSYL */
}
\f
/*
 * Name:        combine_voices()
 *
 * Abstract:    Combine GRPSYLs in voices according to the voicecombine parm.
 *
 * Returns:     void
 *
 * Description: This function, if requested by the voicecombine parameter,
 *		combines the appropriate groups in each chord on each staff
 *		where it can.  (The set of groups in one chord on one staff is
 *		called a "hand" in the following code and in some other places
 *		in Mup, because I get tired of spelling out the whole phrase.)
 *		Because of beaming and ties/slurs, some groups may need to
 *		remain uncombined because their neighbors can't be combined.
 *		So the work is done in three passes.  The first pass looks at
 *		each hand individually to see what can be done there.  The
 *		second pass applies the neighbor rules.  The third pass does
 *		the actual combining.
 */
/*
 * NOTE:  GRPSYL.pvno is used as a scratch area in these functions.  The macro
 * below defines COMB to be pvno for this use.  We rely on the fact that CALLOC
 * initialized it to 0.  We count the low order bit as bit 0.  Two sets of bits
 * are used, as follows.
 *
 * Bit "x+y" being set to 1 means that the GRPSYLs of voices x and y can be
 * combined (looking only at the groups in this chord, not groups they may be
 * tie/beamed to, etc.).  This scheme works only because the only voice numbers
 * are 1, 2, and 3, so that uses bits 3, 4, and 5.  The first pass sets them,
 * and the second pass reads them.
 *
 * Bits 6 through 13 are used in pairs for voice numbers of groups that really
 * should be combined, with all rules applied.  The SHIFT macros below give the
 * rightmost bit of each of the voice numbers, for the two possible sources and
 * destinations that can happen, given that only 3 voices can exist.  Pass 2
 * sets these bits, and pass 3 reads them.
 */
#define COMB		pvno
#define SRC1SHIFT	6
#define DEST1SHIFT	8
#define SRC2SHIFT	10
#define DEST2SHIFT	12

static void
combine_voices()
{
	struct MAINLL *mll_p;	/* point along main linked list */
	struct MAINLL *staffmll_p; /* point a group's staff's MLL struct */
	struct CHORD *ch_p;	/* point along a chord list */
	struct GRPSYL *gs1_p;	/* point along the GRPSYL list of a chord */
	int staff;		/* staff number we are working on */
	int pass;		/* the three passes we must make */


	/* run the three passes */
	for (pass = 1; pass <= 3; pass++) {

		initstructs();			/* clean out old SSV info */

		for (mll_p = Mainllhc_p; mll_p != 0; mll_p = mll_p->next) {

			switch (mll_p->str) {
			case S_SSV:
				/* keep SSVs up to date (but midmeasure SSVs
				 * don't matter for what we're doing here) */
				asgnssv(mll_p->u.ssv_p);
				continue;
			case S_CHHEAD:
				break;	/* break out to handle the chords */
			default:
				continue;	/* ignore everything else */
			}

			/*
			 * Loop through each chord in this list.
			 */
			for (ch_p = mll_p->u.chhead_p->ch_p; ch_p != 0;
						ch_p = ch_p->ch_p) {
				/*
				 * Loop through the linked list of GRPSYLs
				 * hanging off this chord.  Skip the syllables;
				 * just deal with the groups.
				 */
				gs1_p = ch_p->gs_p;
				staff = 0;	/* before first staff */
				for (;;) {
					/* find first group on next staff */
					while (gs1_p != 0 &&
					       gs1_p->staffno == staff) {
						gs1_p = gs1_p->gs_p;
					}
					if (gs1_p == 0) {  /* no next staff */
						break;
					}

					/* remember this new staff number */
					staff = gs1_p->staffno;

					/* tab ignores vcombine */
					if (is_tab_staff(staff)) {
						continue;
					}

					/* 1-line ignores vcombine */
					if (svpath(staff, STAFFLINES)->
							stafflines == 1) {
						continue;
					}

					/* if no groups, only syls, ignore */
					if (gs1_p->grpsyl == GS_SYLLABLE) {
						continue;
					}

					/* skip staff if only one voice */
					if (svpath(staff, VSCHEME)->vscheme
							== V_1) {
						continue;
					}

					/* get the staff's MLL struct */
					staffmll_p = chmgrp2staffm(
								mll_p, gs1_p);

					switch (pass) {
					case 1:
						/*
						 * Set individual combineability
						 * in the "COMB" field.
						 */
						chkhand1(gs1_p, staffmll_p);
						break;
					case 2:
						/*
						 * Apply the neighbor rules.
						 */
						chkhand2(gs1_p, staffmll_p);
						break;
					case 3:
						/*
						 * Do the actual combining.
						 */
						dohand(gs1_p, staffmll_p);
						break;
					}
				}
			}
		}
	}
}
\f
/*
 * Name:        chkhand1()
 *
 * Abstract:    Find which voices are combineable, ignoring neighbor rules.
 *
 * Returns:     void
 *
 * Description: This function finds out which groups in this hand can be
 *		combined, of the ones requested by the voicecombine parameter,
 *		but ignoring neighbor rules.  It stores the results in
 *		the COMB field of all the groups.
 */

static void
chkhand1(gs1_p, mll_p)

struct GRPSYL *gs1_p;		/* first group in this hand */
struct MAINLL *mll_p;		/* MLL struct for this group */

{
	/*
	 * Index the following by voice number to find the expected "height" of
	 * the voices, relative to each other.  A higher number means we expect
	 * that that voice should normally be higher.
	 */				   /* v1 v2 v3 */
	static int pitch[MAXVOICES + 1] = { 0, 3, 1, 2 };

	struct SSV *ssv_p;		/* the SSV with voice combine info */
	struct GRPSYL *gs_p;		/* point along GRPSYLs of the chord */
	/* index the following by vno; it points at the GRPSYL for this vno */
	struct GRPSYL *v_p[MAXVOICES + 1];
	int slot1, slot2;		/* indices into SSV's vcombine array */
	int firstvno, secondvno;	/* two voices from ssv_p->vcombine[] */
	int combineable;		/* YES or NO */
	int comb;			/* accumulate combineable bits */


	/* point at each group; if only one, no combining can be done */
	if (setgrpptrs(gs1_p, v_p) == 1) {
		return;
	}

	/* get the list of groups we want to combine */
	ssv_p = svpath(gs1_p->staffno, VCOMBINE);

	/* for each pair of voices to be combined, see if they can be */
	comb = 0;
	for (slot1 = 0; slot1 < MAXVOICES; slot1++) {
		firstvno = ssv_p->vcombine[slot1];
		if (firstvno == 0) {
			break;	/* end of list, done with outer loop */
		}
		/* voice must have a group in this chord */
		if (v_p[firstvno] == 0) {
			continue;	/* skip this iteration */
		}
		for (slot2 = slot1 + 1; slot2 < MAXVOICES; slot2++) {
			secondvno = ssv_p->vcombine[slot2];
			if (secondvno == 0) {
				break;	/* end of list, done with inner loop */
			}
			/* voice must have a group in this chord */
			if (v_p[secondvno] == 0) {
				continue;	/* skip this iteration */
			}
			/* must pass higher voice first */
			if (pitch[firstvno] > pitch[secondvno]) {
				combineable = chk2groups(v_p[firstvno],
					v_p[secondvno], mll_p,
					ssv_p->vcombinequal);
			} else {
				combineable = chk2groups(v_p[secondvno],
					v_p[firstvno], mll_p,
					ssv_p->vcombinequal);
			}

			/* if this pair was combineable, remember that */
			if (combineable == YES) {
				comb |= 1 << (firstvno + secondvno);
			}
		}
	}

	/* save comb in all the groups, for easy access */
	for (gs_p = gs1_p; gs_p != 0 && gs_p->staffno == gs1_p->staffno &&
			gs_p->grpsyl == GS_GROUP; gs_p = gs_p->gs_p) {
		gs_p->COMB = comb;
	}
}
\f
/*
 * Name:        chk2groups()
 *
 * Abstract:    Find whether two groups are combineable.
 *
 * Returns:     YES or NO
 *
 * Description: This function finds out if the given groups can be combined,
 *		ignoring beam and tie/slur issues.  If either has preceding
 *		grace groups, they are also checked (via recursive calls) and
 *		they must also be able to be combined, to get a YES answer.
 */

static int
chk2groups(hi_p, lo_p, mll_p, qual)

struct GRPSYL *hi_p;		/* group that should have higher pitch */
struct GRPSYL *lo_p;		/* group that should have lower pitch */
struct MAINLL *mll_p;		/* MLL struct for this group */
int qual;			/* voice combine qualifier */

{
	struct GRPSYL *phi_p;	/* group before hi_p */
	struct GRPSYL *plo_p;	/* group before lo_p */
	struct MAINLL *tempmll_p; /* temp copy of mll_p */
	int widx;		/* index into "with" lists */
	int hidx, lidx;		/* index into note lists */
	int mintop;		/* steps above c0 of top group's lowest note */
	int maxbot;		/* steps above c0 of bot group's highest note */
	int n;			/* loop variable */
	struct NOTE *hnote_p;	/* point at a note in the high group */
	struct NOTE *lnote_p;	/* point at a note in the low group */
	struct SLURTO *hslur_p;	/* point at a slur in the high group */
	struct SLURTO *lslur_p;	/* point at a slur in the high group */


	/*
	 * Since the groups are in the same chord, we know they start at the
	 * same time.  Require that they end at the same time.
	 */
	if (NE(hi_p->fulltime, lo_p->fulltime)) {
		return (NO);
	}

	/* covered by the fulltime check, except for bizarre tuplet cases */
	if (hi_p->basictime != lo_p->basictime) {
		return (NO);
	}
	if (hi_p->dots != lo_p->dots) {
		return (NO);
	}

	/* don't allow "mr" and "1r" (for example) to combine */
	if (hi_p->is_meas != lo_p->is_meas) {
		return (NO);
	}

	/* tuploc must agree */
	if (hi_p->tuploc != lo_p->tuploc) {
		return (NO);
	}

	/* tupcont must agree */
	if (hi_p->tupcont != lo_p->tupcont) {
		return (NO);
	}

	/* if printtup is set in both groups, they must agree */
	if (hi_p->printtup != PT_DEFAULT && lo_p->printtup != PT_DEFAULT &&
	    hi_p->printtup != lo_p->printtup) {
		return (NO);
	}

	/* if tupside is set in both groups, they must agree */
	if (hi_p->tupside != PL_UNKNOWN && lo_p->tupside != PL_UNKNOWN &&
	    hi_p->tupside != lo_p->tupside) {
		return (NO);
	}

	/* don't allow cross staff beamed groups */
	if (hi_p->beamto != CS_SAME || lo_p->beamto != CS_SAME) {
		return (NO);
	}

	/* don't allow cross staff stemmed groups */
	if (hi_p->stemto != CS_SAME || lo_p->stemto != CS_SAME) {
		return (NO);
	}

	/* if either is a space, there can be no other conflict */
	if (hi_p->grpcont == GC_SPACE || lo_p->grpcont == GC_SPACE) {
		return (YES);
	}

	/***** both groups are GC_NOTES and/or GC_REST *****/

	/* group size must agree */
	if (hi_p->grpsize != lo_p->grpsize) {
		return (NO);
	}

	/* if both are rests, there can be no other conflict */
	if (hi_p->grpcont == GC_REST && lo_p->grpcont == GC_REST) {
		return (YES);
	}

	/* if only one is a rest, there is a conflict */
	if (hi_p->grpcont == GC_REST || lo_p->grpcont == GC_REST) {
		return (NO);
	}

	/***** both groups are GC_NOTES *****/

	/* head shape must agree */
	if (hi_p->headshape != lo_p->headshape) {
		return (NO);
	}

	/* beaming must be the same on both, except on grace beamloc doesn't
	 * matter, since if we combine them we'll beam them all anyway */
	if (hi_p->beamloc != lo_p->beamloc && hi_p->grpvalue == GV_NORMAL) {
		return (NO);
	}
	if (hi_p->breakbeam != lo_p->breakbeam) {
		return (NO);
	}
	if (hi_p->beamslope != NOBEAMANGLE && lo_p->beamslope != NOBEAMANGLE &&
	    hi_p->beamslope != lo_p->beamslope) {
		return (NO);
	}

	/* if both stemdirs are set, they must agree */
	if (hi_p->stemlen != STEMLEN_UNKNOWN &&
	    lo_p->stemlen != STEMLEN_UNKNOWN &&
	    hi_p->stemlen != lo_p->stemlen) {
		return (NO);
	}

	/* if both stemdirs are forced, they must agree */
	if (hi_p->stemdir != UNKNOWN && lo_p->stemdir != UNKNOWN &&
	    hi_p->stemdir != lo_p->stemdir) {
		return (NO);
	}

	/* group ties out of this group must agree */
	if (hi_p->tie != lo_p->tie) {
		return (NO);
	}

	/* group ties into this group must agree */
	tempmll_p = mll_p;
	phi_p = prevgrpsyl(hi_p, &tempmll_p);
	tempmll_p = mll_p;
	plo_p = prevgrpsyl(lo_p, &tempmll_p);
	if (phi_p != 0 && plo_p != 0 && phi_p->tie != plo_p->tie) {
		return (NO);
	}

	/* tremelo slashes or alternation slashes must agree */
	if (hi_p->slash_alt != lo_p->slash_alt) {
		return (NO);
	}

	/* neither group can have a horizontal offset */
	if (hi_p->ho_usage != HO_NONE || lo_p->ho_usage != HO_NONE) {
		return (NO);
	}

	/* "with" lists must both be nonexistent, or else identical */
	if (hi_p->nwith != lo_p->nwith) {
		return (NO);
	}
	for (widx = 0; widx < hi_p->nwith; widx++) {
		if (strcmp(hi_p->withlist[widx], lo_p->withlist[widx]) != 0) {
			return (NO);
		}
	}

	/*
	 * Rolls aren't really implemented for voice 3.  Voice 3 is just along
	 * for the ride, if it's in the middle of a roll.  So we'll let it
	 * combine as long as both groups are in a roll, or not.  But for
	 * voices 1 and 2, only allow specific combinations that make sense.
	 */
	if (hi_p->vno == 1 && lo_p->vno == 2) {
		switch ((hi_p->roll << 8) | lo_p->roll) {
		case (NOITEM	<< 8) | NOITEM:
			break;
		case (STARTITEM << 8) | INITEM:
		case (STARTITEM << 8) | ENDITEM:
		case (INITEM	<< 8) | INITEM:
		case (INITEM	<< 8) | ENDITEM:
			if (hi_p->rolldir != lo_p->rolldir) {
				return (NO);
			}
			break;
		default:
			return (NO);
		}
	} else {
		if ((hi_p->roll == NOITEM) != (lo_p->roll == NOITEM)) {
			return (NO);
		}
	}

	/*
	 * If each group is preceded by a grace group, those grace groups must
	 * also be combineable.  Notice that if there are multiple preceding
	 * grace groups, more recursive calls will occur.  If one is preceded
	 * and the other isn't, there is no problem and nothing to check.
	 */
	if (hi_p->prev != 0 && hi_p->prev->grpvalue == GV_ZERO &&
	    lo_p->prev != 0 && lo_p->prev->grpvalue == GV_ZERO) {
		if (chk2groups(hi_p->prev, lo_p->prev, mll_p, qual) == NO) {
			return (NO);
		}
	}

	/* if either is a mrpt, the other must be, and there is no conflict */
	if (hi_p->is_meas == YES) {
		return (YES);
	}

	/***** both groups have a notelist *****/

	/*
	 * Do some checks involving overlapping of the groups.  We'd like to
	 * use stepsup, but it won't be set to its correct value until
	 * setnotes.c.  Fortunately, we don't need to know the absolute
	 * vertical position, only the relative.  So just use steps above c0.
	 */
	mintop = hi_p->notelist[hi_p->nnotes - 1].octave * 7 +
		Letshift[hi_p->notelist[hi_p->nnotes - 1].letter - 'a'];
	maxbot = lo_p->notelist[0].octave * 7 +
		Letshift[lo_p->notelist[0].letter - 'a'];
	/*
	 * If the lowest note of the high group is higher than the highest of
	 * the low group, we are okay regardless of the vcombine qualifier,
	 * and there are no shared notes to check.
	 */
	if (mintop > maxbot) {
		return (YES);
	}

	/* if they are equal, and parm doesn't allow it, fail */
	if (mintop == maxbot && qual == VC_NOOVERLAP) {
		return (NO);
	}

	/* if there is true overlap, and parm doesn't allow it, fail */
	if (mintop < maxbot && qual != VC_OVERLAP) {
		return (NO);
	}

	/*
	 * Any shared notes must be compatible, so check every note in the top
	 * group against every note in the bottom group.  If any are equal,
	 * they must be compatible.
	 */
	for (hidx = 0; hidx < hi_p->nnotes; hidx++) {

		hnote_p = &hi_p->notelist[hidx];

		for (lidx = 0; lidx < lo_p->nnotes; lidx++) {

			lnote_p = &lo_p->notelist[lidx];

			/* if the notes aren't equal, don't check them */
			if (hnote_p->octave != lnote_p->octave ||
			    hnote_p->letter != lnote_p->letter) {
				/* the notes differ; no problem */
				continue;
			}

			/* notes match; check all the items that must agree */

			/* any slurs they have must be the same */
			if (hnote_p->nslurto != lnote_p->nslurto) {
				return (NO);
			}
			for (n = 0; n < hnote_p->nslurto; n++) {
				hslur_p = &hnote_p->slurtolist[n];
				lslur_p = &lnote_p->slurtolist[n];
				if (hslur_p->letter != lslur_p->letter) {
					return (NO);
				}
				if (hslur_p->octave != lslur_p->octave) {
					return (NO);
				}
				if (hslur_p->slurstyle != lslur_p->slurstyle) {
					return (NO);
				}
				if (hslur_p->slurdir != lslur_p->slurdir) {
					return (NO);
				}
			}

			/* must have same accidental, or none */
			if (hnote_p->accidental != lnote_p->accidental) {
				return (NO);
			}

			/* head shape override, or none, must agree */
			if (hnote_p->headshape != lnote_p->headshape) {
				return (NO);
			}

			/* note size must agree */
			if (hnote_p->notesize != lnote_p->notesize) {
				return (NO);
			}

			/* tie related attributes must be the same */
			if (hnote_p->tie != lnote_p->tie) {
				return (NO);
			}
			if (hnote_p->tiestyle != lnote_p->tiestyle) {
				return (NO);
			}
			if (hnote_p->tiedir != lnote_p->tiedir) {
				return (NO);
			}
			if (hnote_p->is_bend != lnote_p->is_bend) {
				return (NO);
			}
			if (hnote_p->smallbend != lnote_p->smallbend) {
				return (NO);
			}
		}
	}

	return (YES);	/* passed all tests, the groups are combineable */
}
\f
/*
 * Name:        chkhand2()
 *
 * Abstract:    Make final decision on what can be combined in this hand.
 *
 * Returns:     void
 *
 * Description: This function applies the additional rules about beaming and
 *		ties/slurs to the results of chkhand1(), to decide what groups
 *		in this hand truly should be combined.  It stores the results
 *		in the COMB field of all the groups.
 */

static void
chkhand2(gs1_p, mll_p)

struct GRPSYL *gs1_p;		/* first group in this hand */
struct MAINLL *mll_p;		/* MLL struct for this group */

{
	struct SSV *ssv_p;		/* the SSV with voice combine info */
	/* index the following by vno; it points at the GRPSYL for this vno */
	struct GRPSYL *v_p[MAXVOICES + 1];
	int slot1, slot2;		/* indices into SSV's vcombine array */
	int firstvno, secondvno;	/* two voices from ssv_p->vcombine[] */
	int keep_going;			/* try some more? */


	/* if we already know no combining can be done, get out */
	if (gs1_p->COMB == 0) {
		return;
	}

	/* point at all the groups in this hand */
	(void)setgrpptrs(gs1_p, v_p);

	/* get the list of groups we want to combine */
	ssv_p = svpath(gs1_p->staffno, VCOMBINE);

	/* for each pair of voices to be combined, apply the neighbor rules */
	for (slot1 = 0; slot1 < MAXVOICES; slot1++) {
		firstvno = ssv_p->vcombine[slot1];
		if (firstvno == 0) {
			break;	/* end of list, done with outer loop */
		}
		/* voice must have a group in this chord */
		if (v_p[firstvno] == 0) {
			continue;	/* skip this iteration */
		}
		for (slot2 = slot1 + 1; slot2 < MAXVOICES; slot2++) {
			secondvno = ssv_p->vcombine[slot2];
			if (secondvno == 0) {
				break;	/* end of list, done with inner loop */
			}
			/* voice must have a group in this chord */
			if (v_p[secondvno] == 0) {
				continue;	/* skip this iteration */
			}
			/*
			 * The group with the lower voice number should be the
			 * one that absorbs the other.  Pass it first.
			 */
			if (firstvno < secondvno) {
				keep_going = chk2neighbors(v_p[firstvno],
						v_p[secondvno], gs1_p, mll_p);
			} else {
				keep_going = chk2neighbors(v_p[secondvno],
						v_p[firstvno], gs1_p, mll_p);
			}

			/* get out now if we are told to */
			if (keep_going == NO) {
				return;
			}
		}
	}
}
\f
/*
 * Name:        chk2neighbors()
 *
 * Abstract:    Apply beaming and tie/slur rules to two groups in a hand.
 *
 * Returns:     YES or NO: should any further combining be attempted?
 *
 * Description: This function checks whether the two groups should be combined,
 *		by looking at neighboring groups if beaming or ties/slurs
 *		are involved.  It stores the answer in the COMB field of all
 *		the groups.
 *
 *		If we shouldn't combine the groups, we return YES so that we
 *		can come back and try a different pair, if appropriate.  If we
 *		can combine the groups, we may return YES or NO; see comments
 *		below.
 */

static int
chk2neighbors(dest_p, src_p, gs1_p, mll_p)

struct GRPSYL *dest_p;		/* group that should absorb the other */
struct GRPSYL *src_p;		/* group that should be absorbed */
struct GRPSYL *gs1_p;		/* first group in staff/chord */
struct MAINLL *mll_p;		/* MLL struct for these groups' staff */

{
	struct GRPSYL *d2_p, *s2_p;	/* point at neighboring groups */
	struct GRPSYL *gs_p;		/* point at groups in this chord */
	struct MAINLL *mll2_p, *mll3_p;	/* more pointers into MLL */
	short mask;			/* to be applied to "COMB" */
	short comb;			/* hold combineability bits */
	int keep_going;			/* return code */


	/*
	 * Set up the bit that we must check in each chord to see if these two
	 * voices are combineable.
	 */
	mask = 1 << (dest_p->vno + src_p->vno);

	/*
	 * Start at this chord, and keep looking to the right as long as the
	 * groups are beamed or tied/slurred.
	 */
	mll2_p = mll_p;
	for (d2_p = dest_p, s2_p = src_p; d2_p != 0 && s2_p != 0;
			d2_p = nextglobnongrace(d2_p, &mll2_p),
			s2_p = nextglobnongrace(s2_p, &mll2_p)) {
		/*
		 * If the groups in that chord are not combineable, we must not
		 * combine our original groups either.  The same flags are set
		 * in d2_p and s2_p, so we could have checked either.
		 */
		if ((d2_p->COMB & mask) == 0) {
			return (YES);
		}

		/*
		 * If the groups are not beamed or tied/slurred to the right,
		 * we don't have to look any farther.  For beams, we only have
		 * to check one group, since the other must agree or we
		 * wouldn't be here.  For ties/slurs, we only have to check the
		 * the src, since those are the ones that wouldn't work if
		 * these groups were combined and the next ones weren't.
		 */
		if ((s2_p->beamloc == NOITEM || s2_p->beamloc == ENDITEM) &&
				hastieslur(s2_p) == NO) {
			break;
		}
	}

	/*
	 * Start at this chord, and keep looking to the left as long as the
	 * groups are beamed or tied/slurred.
	 */
	mll2_p = mll_p;
	for (d2_p = dest_p, s2_p = src_p; d2_p != 0 && s2_p != 0;
			d2_p = prevglobnongrace(d2_p, &mll2_p),
			s2_p = prevglobnongrace(s2_p, &mll2_p)) {

		if ((d2_p->COMB & mask) == 0) {
			return (YES);
		}

		mll3_p = mll2_p;	/* don't alter mll2_p */
		if ((s2_p->beamloc == NOITEM || s2_p->beamloc == STARTITEM) &&
		    hastieslur(prevglobnongrace(s2_p, &mll3_p)) == NO) {
			break;
		}
	}

	/* for convenience, copy the COMB bits into a local variable */
	comb = dest_p->COMB;

	/*
	 * We passed all the tests, so remember that we should combine the
	 * original groups.  Also decide whether any more should be tried.
	 */
	if (((comb >> SRC1SHIFT) & 0x3) == 0) {
		/* first groups to be combined in this hand */
		comb |=  src_p->vno <<  SRC1SHIFT;
		comb |= dest_p->vno << DEST1SHIFT;
		/*
		 * If chkhand1() said all the groups in this hand were
		 * combineable, we can come back later and try to combine the
		 * other group.  Otherwise, don't.  We know the non-combineable
		 * group will fail to combine, so don't waste the time.
		 */
		if ((comb & 0x38) == ((1 << (1 + 2)) | (1 << (1 + 3)) |
				(1 << (2 + 3)))) {
			keep_going = YES;
		} else {
			keep_going = NO;
		}
	} else {
		/* second groups to be combined in this hand */
		comb |=  src_p->vno <<  SRC2SHIFT;
		comb |= dest_p->vno << DEST2SHIFT;
		keep_going = NO;	/* only 2 combinings can be done */
	}

	/*
	 * Since we will combine these two groups, the new dest group has
	 * inherited any incompatibility that src might have had with the
	 * other group (if any).  So find the new value of the comb bits.
	 * Set this new comb value into all the groups in this hand.  We do
	 * this for the benefit of later chords on this staff, if they are
	 * beamed or tied/slurred to us.
	 */
	switch (dest_p->vno + src_p->vno) {
	case 1 + 2:	/* combined 2 into 1 */
		/* if 2 and 3 can't combine, now 1 and 3 can't */
		if ((comb & (1 << (2 + 3))) == 0) {
			comb &= ~(1 << (1 + 3));
		}
		break;
	case 1 + 3:	/* combined 3 into 1 */
		/* if 3 and 2 can't combine, now 1 and 2 can't */
		if ((comb & (1 << (3 + 2))) == 0) {
			comb &= ~(1 << (1 + 2));
		}
		break;
	case 2 + 3:	/* combined 3 into 2 */
		/* if 3 and 1 can't combine, now 2 and 1 can't */
		if ((comb & (1 << (3 + 1))) == 0) {
			comb &= ~(1 << (2 + 1));
		}
		break;
	}
	for (gs_p = gs1_p; gs_p != 0 && gs_p->staffno == gs1_p->staffno &&
			gs_p->grpsyl == GS_GROUP; gs_p = gs_p->gs_p) {
		gs_p->COMB = comb;
	}

	return (keep_going);
}
\f
/*
 * Name:        dohand()
 *
 * Abstract:    Combine the appropriate GRPSYLs in one chord on one staff.
 *
 * Returns:     void
 *
 * Description: This function combines GRPSYLs in one chord on one staff.  It
 *		uses the previously determined list of what is combineable in
 *		gs1_p->COMB.
 */

static void
dohand(gs1_p, mll_p)

struct GRPSYL *gs1_p;		/* first group on this staff in this chord */
struct MAINLL *mll_p;		/* MLL struct for this group */

{
	/* index the following by vno; it points at the GRPSYL for this vno */
	struct GRPSYL *v_p[MAXVOICES + 1];
	int srcv, destv;	/* src and dest voice numbers */


	/* if we already know no combining can be done, get out */
	if (gs1_p->COMB == 0) {
		return;
	}

	/* point at all the groups in this hand */
	(void)setgrpptrs(gs1_p, v_p);

	/* get first src group's voice number */
	srcv = (gs1_p->COMB >> SRC1SHIFT) & 0x3;

	if (srcv != 0) {
		/* find the dest's voice and combine */
		destv = (gs1_p->COMB >> DEST1SHIFT) & 0x3;
		comb2groups(v_p[destv], v_p[srcv], mll_p);

		/* get second src group's voice number */
		srcv = (gs1_p->COMB >> SRC2SHIFT) & 0x3;

		if (srcv != 0) {
			/* find the dest's voice and combine */
			destv = (gs1_p->COMB >> DEST2SHIFT) & 0x3;
			comb2groups(v_p[destv], v_p[srcv], mll_p);
		}
	}
}
\f
/*
 * Name:        comb2groups()
 *
 * Abstract:    Combine one group into another.
 *
 * Returns:     void
 *
 * Description: This function combines the src group into the dest group,
 *		including handling any preceding grace groups.
 */

static void
comb2groups(dest_p, src_p, mll_p)

struct GRPSYL *dest_p;		/* group that should absorb the other */
struct GRPSYL *src_p;		/* group that should be absorbed */
struct MAINLL *mll_p;		/* MLL struct for these groups' staff */

{
	struct GRPSYL *dgrace_p;	/* dest grace group */
	struct GRPSYL *sgrace_p;	/* src grace group */
	struct GRPSYL *dmem_p;		/* remember a group from dest voice */
	struct GRPSYL *smem_p;		/* remember a group from src voice */
	struct GRPSYL *temp_p;		/* temp pointer */
	struct GRPSYL *fgs_p;		/* first grace in src voice */


	/*
	 * Add the src into the dest, and make the src group into a space if it
	 * isn't already a space.
	 */
	addsrc2dest(dest_p, src_p);
	if (src_p->grpcont != GC_SPACE) {
		src_p->grpcont = GC_SPACE;
		src_p->grpvalue = GV_NORMAL;
		src_p->grpsize = GS_NORMAL;
		src_p->headshape = HS_UNKNOWN;
		src_p->beamloc = NOITEM;
		src_p->beamslope = NOBEAMANGLE;
		src_p->stemlen = STEMLEN_UNKNOWN;
		src_p->stemdir = UNKNOWN;
		src_p->breakbeam = NO;
		src_p->beamloc = NOITEM;
		src_p->notelist = 0;
		src_p->nnotes = 0;
		src_p->tie = NO;
		src_p->slash_alt = 0;
		src_p->restdist = NORESTDIST;
		src_p->nwith = 0;
		src_p->roll = NOITEM;
	}

	/* if source has no grace notes, we're done */
	if (src_p->prev == 0 || src_p->prev->grpvalue == GV_NORMAL) {
		return;
	}

	/*
	 * Loop through the matching grace groups preceding the src and dest
	 * groups, adding the src into the dest.  Remember the leftmost pair,
	 * or the nongrace groups if there are no matching pairs.
	 */
	dmem_p = dest_p;
	smem_p = src_p;
	for (sgrace_p = src_p->prev, dgrace_p = dest_p->prev;
	     sgrace_p != 0 && sgrace_p->grpvalue == GV_ZERO &&
	     dgrace_p != 0 && dgrace_p->grpvalue == GV_ZERO;
	     sgrace_p = sgrace_p->prev, dgrace_p = dgrace_p->prev) {

		addsrc2dest(dgrace_p, sgrace_p);
		dmem_p = dgrace_p;	/* remember last one done */
		smem_p = sgrace_p;
	}

	if (sgrace_p != 0 && sgrace_p->grpvalue == GV_ZERO) {
		/* extra src grace group(s) left over must be moved */

		/* sgrace_p is the last (rightmost) grace to move */
		for (temp_p = sgrace_p; temp_p != 0 && temp_p->grpvalue ==
				GV_ZERO; temp_p = temp_p->prev) {
			fgs_p = temp_p;
		}
		/* fgs_p is the first (leftmost) grace to move */

		if (dgrace_p == 0) {	/* at start of measure? */
			/* in src voice, skip over all the graces */
			mll_p->u.staff_p->groups_p[src_p->vno-1] = src_p;
			src_p->prev = 0;

			/* splice the left grace into the dest voice */
			mll_p->u.staff_p->groups_p[dest_p->vno-1] = fgs_p;
			fgs_p->prev = 0;
		} else {
			/* in src voice, skip over all the graces */
			fgs_p->prev->next = src_p;
			src_p->prev = fgs_p->prev;

			/* splice the left grace into the dest voice */
			dgrace_p->next = fgs_p;
			fgs_p->prev = dgrace_p;
		}

		/* splice the rightmost left over grace into the dest voice */
		dmem_p->prev = sgrace_p;
		sgrace_p->next = dmem_p;

		/*
		 * If there is now more than one grace in the dest, we have to
		 * correct beamloc in a couple places.
		 */
		if (fgs_p != dest_p->prev) {
			/*
			 * If the dest voice had multiple graces before, the
			 * leftmost one, which was STARTITEM, must be made
			 * INITEM.  If it had only one, it was NOITEM and
			 * must be made ENDITEM, but go ahead and set INITEM;
			 * it'll be set correctly below.
			 */
			if (dmem_p != dest_p) {	  /* if dest had grace(s) */
				dmem_p->beamloc = INITEM;
			}

			/* rightmost dest grace must always be made ENDITEM */
			dest_p->prev->beamloc = ENDITEM;
		}

		/* change the voice number of the moved graces */
		for (temp_p = fgs_p; temp_p != sgrace_p->next;
				temp_p = temp_p->next) {
			temp_p->vno = dest_p->vno;
		}
	} else {
		/* no extra src grace group(s); just remove all src graces */
		if (sgrace_p == 0) {
			mll_p->u.staff_p->groups_p[src_p->vno-1] = src_p;
			src_p->prev = 0;
		} else {
			smem_p->prev->next = src_p;
			src_p->prev = smem_p->prev;
		}
	}
	/* could free the src graces, but is it worth the trouble? */
}
\f
/*
 * Name:        addsrc2dest()
 *
 * Abstract:    Adds src group to dest group.
 *
 * Returns:     void
 *
 * Description: This function adds the src group info (if the src group exists)
 *		into the dest group.  But it doesn't mess with linkages.  That
 *		is the calling function's job.
 */

static void
addsrc2dest(dest_p, src_p)

struct GRPSYL *dest_p;		/* destination group must exist */
struct GRPSYL *src_p;		/* source group, or can be NULL */

{
	struct NOTE *dnote_p;	/* point at a note in the destination group */
	struct NOTE *snote_p;	/* point at a note in the source group */
	struct NOTE *newlist;	/* combined notelist */
	int didx, sidx;		/* index into dest and src note lists */
	int totnotes;		/* total number of notes after combining */
	int n;			/* loop variable */


	/* if src doesn't exist, there is nothing to do */
	if (src_p == 0) {
		return;
	}

	/* move references to the src group's coords */
	upd_ref(src_p->c, dest_p->c);

	/* if src is space, nothing to do except carry over this space field */
	if (src_p->grpcont == GC_SPACE) {
		if (dest_p->grpcont == GC_SPACE &&
				src_p->uncompressible == YES) {
			dest_p->uncompressible = YES;
		}
		return;
	}

	/* padding is the max of the two groups */
	dest_p->padding = MAX(dest_p->padding, src_p->padding);

	/*
	 * Some fields were allowed to disagree between the groups as long as
	 * one was defaulted.  The non-default value should prevail.
	 */
	if (src_p->printtup != PT_DEFAULT) {
		dest_p->printtup = src_p->printtup;
	}
	if (src_p->tupside != PL_UNKNOWN) {
		dest_p->tupside = src_p->tupside;
	}
	if (src_p->beamslope != NOBEAMANGLE) {
		dest_p->beamslope = src_p->beamslope;
	}
	if (src_p->stemlen != STEMLEN_UNKNOWN) {
		dest_p->stemlen = src_p->stemlen;
	}
	if (src_p->stemdir != UNKNOWN) {
		dest_p->stemdir = src_p->stemdir;
	}

	/* only when combining 1 & 2 might we have to adjust roll */
	if (dest_p->vno == 1 && src_p->vno == 2) {
		switch ((dest_p->roll << 8) | src_p->roll) {
		case (NOITEM	<< 8) | NOITEM:
			/* dest remains NOITEM */
			break;
		case (STARTITEM << 8) | INITEM:
			/* dest remains STARTITEM */
			break;
		case (STARTITEM << 8) | ENDITEM:
			dest_p->roll = LONEITEM;
			break;
		case (INITEM	<< 8) | INITEM:
			/* dest remains INITEM */
			break;
		case (INITEM	<< 8) | ENDITEM:
			dest_p->roll = ENDITEM;
			break;
		}
	}

	/* if one is a rest, so is the other; combine */
	if (dest_p->grpcont == GC_REST) {
		/* throw away any restdist; probably would be inappropriate */
		dest_p->restdist = 0;
		return;
	}

	/* if either is a mrpt, the other must be; nothing to copy */
	if (dest_p->is_meas == YES) {
		return;
	}

	/* at this point we know src has notes, & dest has notes or is space */

	/*
	 * Make a new notelist.  First copy the old dest notes into there, and
	 * then add the src notes.  We can't just realloc the dest, since
	 * pointers into the array must be updated by calling upd_ref for each
	 * array element.  If any notes are shared, we won't really need this
	 * many, but it doesn't waste much memory.
	 */
	MALLOC(NOTE, newlist, dest_p->nnotes + src_p->nnotes);
	for (n = 0; n < dest_p->nnotes; n++) {
		newlist[n] = dest_p->notelist[n];
	}

	/*
	 * Keep track of the number of total resulting notes, which starts out
	 * as the number of notes in dest.  Loop through the src notes.
	 */
	totnotes = dest_p->nnotes;
	for (sidx = 0; sidx < src_p->nnotes; sidx++) {
		snote_p = &src_p->notelist[sidx];

		/* see if it matches any of the dest notes in the result array*/
		for (didx = 0; didx < dest_p->nnotes; didx++) {
			dnote_p = &newlist[didx];
			if (dnote_p->octave == snote_p->octave &&
			    dnote_p->letter == snote_p->letter) {
				/*
				 * If one has parens on the note or acc and the
				 * other doesn't, ensure no parens in result.
				 */
				if (dnote_p->note_has_paren !=
				    snote_p->note_has_paren) {
					dnote_p->note_has_paren = NO;
				}
				if (dnote_p->acc_has_paren !=
				    snote_p->acc_has_paren) {
					dnote_p->acc_has_paren = NO;
				}
				break;
			}
		}
		if (didx == dest_p->nnotes) {
			/* didn't find a match, so add it to the end */
			newlist[totnotes++] = *snote_p;
		}
	}

	/* sort the combined list in pitch order */
	qsort((char *)newlist, (unsigned int)totnotes,
			sizeof (struct NOTE), notecomp);

	/*
	 * For every original dest and src note, find out where it ended up in
	 * the combined list, and update and location tag references.
	 */
	for (didx = 0; didx < dest_p->nnotes; didx++) {
		dnote_p = &dest_p->notelist[didx];
		for (n = 0; n < totnotes; n++) {
			if (newlist[n].octave == dnote_p->octave &&
			    newlist[n].octave == dnote_p->letter) {
				upd_ref(newlist[n].c, dnote_p->c);
			}
		}
	}
	for (sidx = 0; sidx < src_p->nnotes; sidx++) {
		dnote_p = &src_p->notelist[sidx];
		for (n = 0; n < totnotes; n++) {
			if (newlist[n].octave == dnote_p->octave &&
			    newlist[n].octave == dnote_p->letter) {
				upd_ref(newlist[n].c, dnote_p->c);
			}
		}
	}

	/* free old dest list, and install the new one and its note count */
	if (dest_p->notelist != 0) {	/* not a space */
		FREE(dest_p->notelist);
	}
	dest_p->notelist = newlist;
	dest_p->nnotes = totnotes;
}
\f
/*
 * Name:        setgrpptrs()
 *
 * Abstract:    Set pointers to the groups in a hand.
 *
 * Returns:     number of GRPSYLs found in this hand
 *
 * Description: This function fill in the given array with pointers to the
 *		groups in this hand.  When a group doesn't exist for some
 *		voice, a null pointer is used.
 */

static int
setgrpptrs(gs1_p, v_p)

struct GRPSYL *gs1_p;		/* first group in this hand */
struct GRPSYL *v_p[];		/* fill this in, index by voice number */

{
	struct GRPSYL *gs_p;	/* point along GRPSYLs of the chord */
	int v;			/* a voice number */
	int num;		/* number of groups found */


	/* null out the list of pointers initially (note [0] is not used) */
	for (v = 1; v <= MAXVOICES; v++) {
		v_p[v] = 0;
	}
	/* for each group in the hand, set pointer to it */
	num = 0;
	for (gs_p = gs1_p; gs_p != 0 && gs_p->staffno == gs1_p->staffno &&
			gs_p->grpsyl == GS_GROUP; gs_p = gs_p->gs_p) {
		v_p[gs_p->vno] = gs_p;
		num++;
	}

	return (num);
}
\f
/*
 * Name:        hastieslur()
 *
 * Abstract:    Is this group tied/slurred/bent to the next?
 *
 * Returns:     YES or NO
 *
 * Description: This function checks whether there are any ties/slurs/bends to
 *		the next group.  If the given group doesn't exist, the answer
 *		is NO.
 */

static int
hastieslur(gs_p)

struct GRPSYL *gs_p;		/* group to check */

{
	int idx;		/* index into note list */


	/* if there's no group, it isn't tied/slurred */
	if (gs_p == 0) {
		return (NO);
	}

	/* check group tie */
	if (gs_p->tie == YES) {
		return (YES);
	}

	/* check note ties and slurs (bends are covered by slurs) */
	for (idx = 0; idx < gs_p->nnotes; idx++) {
		if (gs_p->notelist[idx].tie == YES ||
		    gs_p->notelist[idx].nslurto != 0) {
			return (YES);
		}
	}

	return (NO);
}