Merge branch 'arkkra' into shiny

[mup] / mup / mup / tie.c

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

/* This file contains functions for handling ties and slurs.
 * This includes doing error checking to make sure
 * there is a note to tie/slur to.
 * There is also code to add padding to make space for ties/slurs
 * that are carried into second endings. */

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



/* lengths of line segments of carried in tie marks */
#define HALFTIEPAD	(3 * STEPSIZE)

/* infomation about a tied or slurred note that gets carried into an ending */
struct TIECARRY {
	short	letter;		/* pitch to be tied or slurred to */
	short	octave;		/* octave of the pitch */
	short	curveno;	/* slurto index or -1 for tie */
	short	is_bend;	/* if slurto is actually a bend */
	struct MAINLL *mll_p;	/* points to first group */
	struct GRPSYL *gs_p;	/* group of first note */
	struct TIECARRY *next;	/* linked list */
};

/* linked list of tie carry info for each staff/voice */
struct TIECARRY *Tiecarryinfolist_p [MAXSTAFFS + 1] [MAXVOICES];

/* flag to mark if there are any carry ins */
static short Have_carry_ins = NO;


/* static functions */
static void do_tie P((struct MAINLL *mll_p));
static void do_group_ties P((struct GRPSYL *gs_p, struct MAINLL *mll_p));
static void chk_slides P((struct NOTE *note_p, struct GRPSYL *gs_p,
		struct MAINLL *mll_p));
static void chk_following4slide P((struct NOTE *note_p, struct GRPSYL *gs_p,
		struct MAINLL *mll_p));
static struct MAINLL *do_carry_ties P((struct MAINLL *staff_mll_p,
		struct MAINLL *bar_mll_p));
static void savetieinfo P((struct MAINLL *mll_p, struct GRPSYL *gs_p));
static void do_save_tieinfo P((int staffno, int vno, int letter, int octave,
		int is_tie, struct MAINLL *mainll_p, struct GRPSYL *gs_p,
		int is_bend));
static void carryin_ties P((struct MAINLL *mll_p));
static void add_carryin P((struct STAFF *staff_p));
static void free_carryin_info P((void));
static void free_cinfo P((struct TIECARRY *carryinfo_p));
static void chk4xpose P((struct MAINLL *mll_p));
static void chkxpstaff P((struct MAINLL *mll_p, int s));
static void chkxpgrp P((struct GRPSYL *gs_p, char *inputfile, int lineno));
static void set_inhibitprint_if_appropriate P((struct GRPSYL *gs_p,
		struct MAINLL *mll_p));
\f


/* go through main list, checking each STAFF struct for ties and slurs.
 * For each, do appropriate error checking */

void
tie()

{
	struct MAINLL * mll_p;	/* walk through main list */


	debug(2, "tie");

	/* first check for any ties across transpositions, and delete them.
	 * Can't do inside the next loop, because by then a less informative
	 * message could be generated for the error */
	initstructs();
	for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
				mll_p = mll_p->next) {
		if (mll_p->str == S_SSV) {
			chk4xpose(mll_p);
			asgnssv(mll_p->u.ssv_p);
		}
	}

	/* go through the main list again for other checks */
	initstructs();
	for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
				mll_p = mll_p->next) {
	
		/* process any GRPSYL lists with note info */
		if (mll_p->str == S_STAFF) {
			if ( (svpath(mll_p->u.staff_p->staffno, VISIBLE))
						->visible == YES) {
				do_tie(mll_p);
			}
		}
		else if (mll_p->str == S_SSV) {
			asgnssv(mll_p->u.ssv_p);
		}
	}
}
\f

/* do the ties and slurs on all groups off a STAFF struct */

static void
do_tie(mll_p)

struct MAINLL *mll_p;	/* the STAFF struct with list of GRPSYLs */

{
	struct GRPSYL *gs_p;		/* walk through GRPSYL list */
	int v;				/* walk through voices per staff */
	int is_tab;			/* YES if tablature staff */


	is_tab = is_tab_staff(mll_p->u.staff_p->staffno);

	for (v = 0; v < MAXVOICES; v++) {
		/* go through entire list of GRPSYLs */
		for (gs_p = mll_p->u.staff_p->groups_p[v];
					gs_p != (struct GRPSYL *) 0;
					gs_p = gs_p->next) {

			/* error check */
			if (gs_p->grpcont != GC_NOTES) {
				if (gs_p->tie == YES) {
					l_warning(mll_p->inputfile,
						mll_p->inputlineno,
					 	"tie can only apply to notes");
					gs_p->tie = NO;
				}

				/* if rest or space, nothing more to do */
				continue;
			}

			do_group_ties(gs_p, mll_p);
			if (is_tab == YES) {
				set_inhibitprint_if_appropriate(gs_p, mll_p);
			}
		}
	}
}
\f

/* do ties on all notes in a group that have ties. While we're at it, also
 * make sure any staffs with clefs not printed, don't have accidentals on any
 * notes  */

static void
do_group_ties(gs_p, mll_p)

struct GRPSYL *gs_p;		/* do ties from this group */
struct MAINLL *mll_p;		/* points to gs_p */

{
	struct GRPSYL *gs2_p;		/* group to tie to */
	register int n;			/* walk through note list */
	struct NOTE *note1_p;		/* info about note */
	struct NOTE *note2_p;		/* note slurred to */
	int slur;			/* index into slurtolist */
	int d;				/* index for deleting illegal slurs */
	short err = NO;			/* error flag */
	short inhibitprint;		/* if to set inhibitprint flag on the
					 * tied-to group (tab staff only) */


	/* if all notes in a group are tied on a tablature staff,
	 * then all the corresponding notes on the tied-to group
	 * should have their inhibitprint flag set. So we need to
	 * find out if that is a possibility */
	if (is_tab_staff(gs_p->staffno) == YES) {
		if (gs_p->tie == YES) {
			inhibitprint = YES;
		}
		else {
			/* first assume that all notes will be tied, then
			 * check them all. If any are found that are not
			 * tied, then turn the inhibitprint flag back off */
			inhibitprint = YES;
			for (n = 0; n < gs_p->nnotes; n++) {
				if (gs_p->notelist[n].tie == NO) {
					inhibitprint = NO;
					break;
				}
			}
		}
	}
	else {
		/* inhibitprint flag is only used on tablature staffs */
		inhibitprint = NO;
	}

	/* go through all notes in group, looking for ties */
	gs2_p = (struct GRPSYL *) 0;
	for (n = 0; n < gs_p->nnotes; n++) {

		/* For staffs without clef, make sure there are no accidentals.
		 * But tab staffs keep accidentals, even with no clef.
		 * Philosophically, this isn't really a good place to
		 * do this, but since we're going through the list of notes
		 * anyway here, and time-wise in the scheme of the program
		 * this is the right time, rather than make yet another trip
		 * through the list later we do it here. But for MIDI
		 * purposes, we need to keep the accidental, or the wrong
		 * note will play! */
		if (svpath(gs_p->staffno, STAFFLINES)->printclef != SS_NORMAL
				&& is_tab_staff(gs_p->staffno) == NO
				&& Doing_MIDI == NO) {
			 gs_p->notelist[n].accidental = '\0';
		}

		note1_p = &(gs_p->notelist[n]);
		/* if this note's tie flag is set, check the tie */
		if ( note1_p->tie == YES) {

			/* if haven't yet found the group to tie to, do that.
			 * (If this is not the first note to be tied
			 * in this group, we would have already found
			 * the other group) */
			if (gs2_p == (struct GRPSYL *) 0) {
				gs2_p = find_next_group(mll_p, gs_p, "tie");
			}

			if (gs2_p == (struct GRPSYL *) 0) {
				/* if nothing to tie to, cancel the tie. We
				 * will have already printed an error msg. */
				note1_p->tie = NO;
				gs_p->tie = NO;
			}
			else {
				/* if the inhibitprint flag is set, set it
				 * in the tied-to group. However,
				 * if the groups have different numbers of
				 * notes and the inhibitprint flag is set,
				 * we have to cancel it, because that only
				 * applies when the tied-from and tied-to
				 * groups have identical notes in them */
				if (inhibitprint == YES) {
					if (gs_p->nnotes == gs2_p->nnotes) {
						gs2_p->inhibitprint = YES;
					}
					/* turn flag off, so we don't
					 * waste time checking it
					 * again for each of the remaining
					 * notes in the group */
					inhibitprint = NO;
				}

				if (find_matching_note(gs2_p, note1_p->letter,
						note1_p->octave, "tie")
						== (struct NOTE *) 0) {
					note1_p->tie = NO;
					gs_p->tie = NO;
				}
			}
		}


		/* handle all slurs from current note */
		for (slur = 0; slur < note1_p->nslurto; slur++) {

			/* slides to/from nowhere don't get processed here */
			if (IS_NOWHERE(note1_p->slurtolist[slur].octave)) {
				continue;
			}

			/* if haven't yet found the group to slur to, do that.
			 * (We may have already found it earlier) */
			if (gs2_p == (struct GRPSYL *) 0) {
				gs2_p = find_next_group(mll_p, gs_p, "slur");
			}

			if (gs2_p == (struct GRPSYL *) 0) {
				/* if nothing to slur to, cancel all slurs */
				note1_p->nslurto = 0;
				continue;
			}

			/* special case of 'M' when a group 'slur'
		 	 * has been specified. Find matching note
			 * in the second chord */
			if (note1_p->slurtolist[slur].letter == 'M') {
				if (gs_p->nnotes != gs2_p->nnotes) {
					/* only print message first time */
					if (err == NO) {
						l_warning(gs_p->inputfile,
							gs_p->inputlineno,
							"'slur' requires equal number of notes in each chord");
					}
					note2_p = (struct NOTE *) 0;

					/* don't do any more on this
					 * chord, to avoid multiple
					 * error messages */
					err = YES;
				}
				else {
					note2_p = & (gs2_p->notelist[n]);
				}
			}
			else {
				note2_p = find_matching_note(gs2_p,
					note1_p->slurtolist[slur].letter,
					note1_p->slurtolist[slur].octave,
					note1_p->is_bend ? "bend" : "slur");
			}

			if (note2_p != (struct NOTE *) 0) {
				/* fill in the letter/octave if they had to
				 * be derived */
				if ((note1_p->slurtolist[slur].letter == 'U')
					 || (note1_p->slurtolist[slur].letter == 'M')
					 || is_tab_staff(gs_p->staffno) == YES) {
				    note1_p->slurtolist[slur].letter =
							note2_p->letter;
				    note1_p->slurtolist[slur].octave =
							note2_p->octave;
				}
			}
			else {
				/* discard this slur--
				 * nothing to slur to */
				for (d = slur + 1; d < note1_p->nslurto; d++) {
					note1_p->slurtolist[d-1] =
						note1_p->slurtolist[d];
				}
				(note1_p->nslurto)--;
			}
		}

		/* do additional slide checks for tab and tabnote */
		if (is_tab_staff(gs_p->staffno) == YES
				|| (gs_p->staffno < MAXSTAFFS
				&& is_tab_staff(gs_p->staffno + 1) == YES)) {
			chk_slides(note1_p, gs_p, mll_p);
		}
	}
}

/* do extra checks for slide. There can be no more than one incoming and one
 * outgoing slide for any given note */

static void
chk_slides(note_p, gs_p, mll_p)

struct NOTE *note_p;		/* this note might have slides */
struct GRPSYL *gs_p;		/* note is in this group */
struct MAINLL *mll_p;		/* group is tied to this main list struct */

{
	int s;		/* index through slurtolist */
	int incoming = 0, outgoing = 0;	/* how many slides of each type */


	/* go through list counting up incoming and outgoing slides */
	for (s = 0; s < note_p->nslurto; s++) {
		switch(note_p->slurtolist[s].octave) {

		case OUT_UPWARD:
		case OUT_DOWNWARD:
			outgoing++;
			break;

		case IN_UPWARD:
		case IN_DOWNWARD:
			incoming++;
			break;

		default:
			outgoing++;
			/* make sure following group doesn't have any
			 * incoming nowhere slides */
			chk_following4slide(note_p, gs_p, mll_p);
			break;
		}
	}

	if (incoming > 1) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"can't have more than one slide into a note");
	}
	if (outgoing > 1) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"can't have more than one slide from a note");

	}
}
\f

/* Given a note with a slide to a specific fret,
 * if there is a following group, see if it has a matching note,
 * and if so, check that note's slurtolist to see if it
 * contains any incoming nowhere slides. If so, there is a
 * problem, because we already have a slide to that note */

static void
chk_following4slide(note_p, gs_p, mll_p)

struct NOTE *note_p;	/* this note has a slide to a specific fret */
struct GRPSYL *gs_p;	/* note is in this group */
struct MAINLL *mll_p;	/* group is attached to this main list struct */

{
	struct GRPSYL *ngs_p;	/* next group */
	int n;			/* index through notes */
	int ns;			/* index through slides on next group note */


	if ((ngs_p = nextgrpsyl(gs_p, &mll_p)) == (struct GRPSYL *) 0) {
		/* no next group, so no problem */
		return;
	}

	/* check each note in next group */
	for (n = 0; n < ngs_p->nnotes; n++) {
		/* is this the matching note?  If the letter matches and
		 * either it's a tab staff or the octave also matches,
		 * then it is the matching note. */
		if (ngs_p->notelist[n].letter == note_p->letter &&
				(is_tab_staff(gs_p->staffno) ||
				ngs_p->notelist[n].octave == note_p->octave)) {

			/* found the matching note. Check its slurtolist */
			for (ns = 0; ns < ngs_p->notelist[n].nslurto; ns++) {
				switch (ngs_p->notelist[n].slurtolist[ns].octave) {
				case IN_UPWARD:
				case IN_DOWNWARD:
					l_yyerror(gs_p->inputfile,
						gs_p->inputlineno,
						"can't slide to note that has </n> or <\\n>");
					break;
				default:
					break;
				}
			}
		}
	}
}
\f

/* find note in following chord having specified pitch/octave.
 * If the note is found, return pointer to it, otherwise 0
 */

struct NOTE *
find_matching_note(gs_p, letter, octave, type)

struct GRPSYL *gs_p;	/* which GRPSYL we're tying to */
int letter;		/* find note with this pitch, 'a' to 'g' */
int octave;		/* find note with this octave */
char *type;		/* "tie", "slur", "slide", or "bend",
			 * or null if not to print any error messages */

{
	struct NOTE *note2_p;	/* note to tie to */
	register int n2;	/* index through notelist of 2nd group */


	if (gs_p == (struct GRPSYL *) 0) {
		return( (struct NOTE *) 0);
	}

	/* we don't allow tie/slur into a measure repeat. */
	if (is_mrpt(gs_p) == YES) {
		l_warning(gs_p->inputfile, gs_p->inputlineno,
			"tie/slur/bend not allowed into measure rpt");
		return (struct NOTE *) 0;
	}

	/* special case. On slurto, if second group has only a single
	 * note, user doesn't have to specify it. We will have marked the
	 * pitch as 'U'. If second group has only one note in it, use that
	 * one. If not, error */
	if ( letter == 'U') {
		if ( gs_p->nnotes != 1) {
			if (type != (char *) 0) {
				l_warning(gs_p->inputfile, gs_p->inputlineno,
					"note to %s to not specified", type);
			}
			return(struct NOTE *) 0;
		}
		else {
			return( &(gs_p->notelist[0]) );
		}
	}

	/* try to find matching note in second note group */
	/* If first note has an accidental and the corresponding one in
	 * the next group doesn't, that's a
	 * match, 'cause we only print the accidental once.
	 */
	for (n2 = 0; n2 < gs_p->nnotes; n2++) {

		note2_p = &(gs_p->notelist[n2]);

		if (is_tab_staff(gs_p->staffno) == YES) {
			/* on tab staff, we just have to match
			 * the string number */
			if (note2_p->letter == letter) {
				return(note2_p);
			}
			else {
				continue;
			}
		}

		if ( (note2_p->letter == letter)
				&& (note2_p->octave == octave) ) {

			if (type != (char *) 0 && (strcmp(type, "tie") == 0)
					&& (note2_p->accidental != '\0')
					&& is_tab_staff(gs_p->staffno) == NO) {
				l_warning(gs_p->inputfile, gs_p->inputlineno,
					"second note of tie not allowed to have an accidental");
				/* fix it so in case we're called again on the
				 * same note (which is possible), we'll only
				 * print one error message */
				note2_p->accidental = '\0';
			}

			/* found it! */
			return(note2_p);
		}
	}

	/* oh-oh. User goofed */
	if (is_tab_staff(gs_p->staffno) == YES) {
		if (type != (char *) 0) {
			l_yyerror(gs_p->inputfile, gs_p->inputlineno,
				"can't do %s: %s string not in chord%s",
				type, stringname(letter, gs_p->staffno),
				gs_p->nnotes == 0 ?
				" (in fact no strings at all)" : "");
		}
	}
	else {
		if (type != (char *) 0) {
			if (letter < 'a' || letter > 'g' || octave < MINOCTAVE
						|| octave > MAXOCTAVE) {
				l_warning(gs_p->inputfile, gs_p->inputlineno,
					"can't do %s: note not in chord",
					type);
			}
			else {
				l_warning(gs_p->inputfile, gs_p->inputlineno,
					"can't do %s: %c%d not in chord%s",
					type, letter, octave,
					gs_p->nnotes == 0 ?
					" (in fact no notes at all)" : "");
			}
		}
	}
	return( (struct NOTE *) 0 );
}
\f

/* given one GRPSYL, find the next one in the same staff and voice,
 * which might be in the next measure */

struct GRPSYL *
find_next_group(mll_p, gs_p, type)

struct MAINLL *mll_p;		/* current place in main list */
struct GRPSYL *gs_p;		/* group to tie from */
char *type;			/* "tie" or "slur" */

{
	struct MAINLL *ml_p;

	ml_p = mll_p;
	if ((gs_p = nextgrpsyl(gs_p, &ml_p)) == (struct GRPSYL *) 0) {
		l_warning(mll_p->inputfile, mll_p->inputlineno,
						"no chord to %s to", type);
	}

	return(gs_p);
}
\f

/* go through main list. If we hit a bar that begins an ending, back up
 * and go through the previous measure. If the final group of any voice
 * has any tied or slurred notes, save information about them. Then for
 * each additional beginning of an ending up until an endending, add
 * user padding to allow for carried in tie mark. At the endending, free
 * the information and continue through the rest of the main list */

void
tie_carry()

{
	struct MAINLL *mll_p;			/* walk through main list */
	struct MAINLL *first_staff_mll_p;	/* points to first STAFF
						 * struct of measure */


	debug(2, "tie_carry");

	initstructs();
	first_staff_mll_p = (struct MAINLL *) 0;
	for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->next) {
		switch (mll_p->str) {

		case S_STAFF:
			/* remember where list of staffs begins and skip
			 * the rest of the STAFFs */
			first_staff_mll_p = mll_p;
			for (   ; mll_p->next->str == S_STAFF;
						mll_p = mll_p->next) {
				;
			}
			break;

		case S_BAR:
			if (mll_p->u.bar_p->endingloc == STARTITEM) {
				mll_p = do_carry_ties(first_staff_mll_p, mll_p);
			}
			break;

		case S_CLEFSIG:
			/* actually, it should be impossible to hit this case,
			 * because clefsigs with pseudo-bar haven't been
			 * created yet at the time this is called, but if things
			 * are changed some day so things get done in a different
			 * order, this should then work. */
			if (mll_p->u.clefsig_p->bar_p != (struct BAR *) 0 &&
					mll_p->u.clefsig_p->bar_p->endingloc
					== STARTITEM) {
				mll_p = do_carry_ties(first_staff_mll_p, mll_p);
			}
			break;

		case S_SSV:
			asgnssv(mll_p->u.ssv_p);
			break;
		default:
			break;
		}
	}
}
\f

/* Save info about any ties and slurs on the last chords before the beginning
 * of the ending. Then search forward in main list. If there are any more
 * beginnings of endings, add padding to the appropriate groups.
 * Return MAINLL at the end of the last ending processed. */

static struct MAINLL *
do_carry_ties(staff_mll_p, bar_mll_p)

struct MAINLL *staff_mll_p;	/* first staff in measure which ends on
				 * bar that begins an ending */
struct MAINLL *bar_mll_p;	/* the bar that begins an ending */

{
	struct MAINLL *mll_p;	/* walk through list of staffs */
	int v;			/* voice number */


	/* save all the tie / slur info */
	for (mll_p = staff_mll_p; mll_p->str == S_STAFF; mll_p = mll_p->next) {

		for (v = 0; v < MAXVOICES; v++) {
			savetieinfo(mll_p, mll_p->u.staff_p->groups_p[v]);
		}
	}

	/* now search ahead for other endings */
	for (mll_p = bar_mll_p->next; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->next) {
		if (mll_p->str != S_BAR) {
			continue;
		}

		switch (mll_p->u.bar_p->endingloc) {
		case NOITEM:
		case ENDITEM:
			free_carryin_info();
			return(mll_p);
		case STARTITEM:
			carryin_ties(mll_p->next);
			break;
		default:
			break;
		}
	}
	pfatal("fell off end of list while doing tie carries");
	/*NOTREACHED*/
	return( (struct MAINLL *) 0);
}
\f

/* given a GRPSYL, save info about any notes in it that have ties or slurs */

static void
savetieinfo(mll_p, gs_p)

struct MAINLL *mll_p;		/* main list struct that gs_p is connected to */
struct GRPSYL *gs_p;		/* save info about ties/slurs on last group
				 * in this list */

{
	int n;		/* note index */
	int s;		/* slurto index */


	if (gs_p == (struct GRPSYL *) 0) {
		return;
	}

	/* find last group in list */
 	for (  ; gs_p->next != (struct GRPSYL *) 0; gs_p = gs_p->next) {
		;
	}

	for (n = 0; n < gs_p->nnotes; n++) {

		/* save tie info */
		if (gs_p->notelist[n].tie == YES) {
			do_save_tieinfo(gs_p->staffno, gs_p->vno,
					gs_p->notelist[n].letter,
					gs_p->notelist[n].octave, -1,
					mll_p, gs_p, NO);
		}

		/* save slurto info */
		for (s = 0; s < gs_p->notelist[n].nslurto; s++) {
			do_save_tieinfo(gs_p->staffno, gs_p->vno,
					gs_p->notelist[n].slurtolist[s].letter,
					gs_p->notelist[n].slurtolist[s].octave,
					s, mll_p, gs_p,
					gs_p->notelist[n].is_bend);
		}
	}
}
\f

/* save info about one tie or slur mark that will need to be carried into
 * subsequent endings. Malloc space for info, fill it in, and put into table */

static void
do_save_tieinfo(staffno, vno, letter, octave, curveno, mll_p, gs_p, is_bend)

int staffno;
int vno;
int letter;	/* a to g */
int octave;
int curveno;
struct MAINLL *mll_p;	/* points to first group */
struct GRPSYL *gs_p;	/* group of first note */
int is_bend;		/* YES if is actually a bend rather than slur */

{
	struct TIECARRY *new_p;

	MALLOC(TIECARRY, new_p, 1);
	new_p->letter = (short) letter;
	new_p->octave = (short) octave;
	new_p->curveno = (short) curveno;
	new_p->is_bend = is_bend;
	new_p->mll_p = mll_p;
	new_p->gs_p = gs_p;
	new_p->next = Tiecarryinfolist_p [staffno] [vno - 1];
	Tiecarryinfolist_p [staffno] [vno - 1] = new_p;

	Have_carry_ins = YES;
}
\f

/* Once an ending has been found that may have ties/slurs carried in, use
 * the saved information to add padding. */

static void
carryin_ties(mll_p)

struct MAINLL *mll_p;	/* look for staffs from here for chords that may have
			 * things tied or slurred in */

{
	if (Have_carry_ins == NO) {
		/* nothing to do */
		return;
	}

	/* skip everything up to STAFFS */
	for (  ; mll_p != (struct MAINLL *) 0; mll_p = mll_p->next) {
		if (mll_p->str == S_STAFF) {
			add_carryin(mll_p->u.staff_p);
		}
		else if (mll_p->str == S_BAR) {
			break;
		}
	}
}
\f

/* given a STAFF which is at the beginning of an ending that may have ties/slurs
 * carried in, go through each voice. If there is anything to carry in, 
 * add appropriate padding, then generate curve */

static void
add_carryin(staff_p)

struct STAFF *staff_p;		/* which staff to do ties/slur carry in on */

{
	int staffno;
	int v;				/* voice number */
	int n;				/* index into notelist */
	struct GRPSYL *gs_p;		/* first chord in measure */
	struct TIECARRY *info_p;	/* info about things carried in */
	int found;			/* if matching note found in chord */
	double padding;			/* how much padding to add */


	staffno = staff_p->staffno;
	/* do each carried in item on each voice */
	for (v = 0; v < MAXVOICES; v++) {

		padding = HALFTIEPAD;

		for (info_p = Tiecarryinfolist_p [staffno] [v];
					info_p != (struct TIECARRY *) 0;
					info_p = info_p->next) {

			gs_p = staff_p->groups_p[v];

			/* add padding to allow for carried-in mark */
			gs_p->padding += padding;
			/* only add padding once per chord! */
			padding = 0.0;

			/* mark any notes that will get carried-in mark */
			for (found = NO, n = 0; n <  gs_p->nnotes; n++) {
				if (gs_p->notelist[n].letter
						== info_p->letter &&
						gs_p->notelist[n].octave
						== info_p->octave) {

					/* A carried-in tie on a tablature
					 * staff isn't printed, but the fret
					 * is put in parentheses. */
					if (is_tab_staff(staff_p->staffno) == YES
							&& info_p->curveno == -1) {
						gs_p->notelist[n].FRET_HAS_PAREN = YES;
					}
					found = YES;
					break;
				}
			}

			if (found == NO) {
				l_warning(gs_p->inputfile, gs_p->inputlineno,
					"can't carry tie/slur/bend into ending: %c%d not in chord",
					info_p->letter, info_p->octave);
			}
		}
	}
}
\f

/* free all the tie carry in info */

static void
free_carryin_info()

{
	int s;
	int v;


	for (s = 1; s <= MAXSTAFFS; s++) {
		for (v = 0; v < MAXVOICES; v++) {
			free_cinfo(Tiecarryinfolist_p [s] [v]);
			Tiecarryinfolist_p [s] [v] = (struct TIECARRY *) 0;
		}
	}

	Have_carry_ins = NO;
}


/* recursively free list of tie carry information */

static void
free_cinfo(carryinfo_p)

struct TIECARRY *carryinfo_p;

{
	if (carryinfo_p == (struct TIECARRY *) 0) {
		return;
	}

	free_cinfo(carryinfo_p->next);
	FREE(carryinfo_p);
}
\f

/* check if a transposition occurred, and if so, see if there were any
 * ties that would cross the bar. If so, print warning and discard the tie */

static void
chk4xpose(mll_p)

struct MAINLL *mll_p;	/* containing SSV that might contain transpose */

{
	struct SSV *ssv_p;
	int s;			/* staff index */
	int intnum;		/* transposition interval */
	int inttype;		/* transposition interval type */


	if (mll_p->str != S_SSV) {
		return;
	}

	ssv_p = mll_p->u.ssv_p;
	if (ssv_p->used[TRANSPOSITION] == YES ||
					ssv_p->used[ADDTRANSPOSITION] == YES) {
		/* this SSV changes transpose value, need to check further */
		if (ssv_p->context == C_STAFF) {
			/* if staff now has a different transpose value than
			 * before, need to see if any notes tied over the
			 * previous bar */
			s = ssv_p->staffno;
			totaltrans(s, &inttype, & intnum);
			if (ssv_p->inttype != inttype
					|| ssv_p->intnum != intnum) {
				chkxpstaff(mll_p, s);
			}
		}
		else {
			/* must be score wide change. This is a little
			 * trickier. Go through each staff. If its transpose
			 * value is not set in staff context and it's
			 * different than the new transpose value, then
			 * we need to check for ties */
			for (s = 1; s <= Score.staffs; s++) {
				totaltrans(0, &inttype, & intnum);
				if (Staff[s].used[TRANSPOSITION] == NO &&
					Staff[s].used[ADDTRANSPOSITION] == NO &&
					(ssv_p->inttype != inttype
					|| ssv_p->intnum != intnum)) {
				    chkxpstaff(mll_p, s);
				}
			}
		}
	}
}
\f

/* check a specific staff for possible ties across transposition */

static void
chkxpstaff(mll_p, s)

struct MAINLL *mll_p;	/* look backward in main list from here */
int s;			/* which staff */

{
	int v;


	/* back up to find appropriate staff */
	for (mll_p = mll_p->prev; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->prev) {
		if (mll_p->str == S_STAFF) {
			if (mll_p->u.staff_p->staffno == s) {
				/* found the correct staff. check each voice */
				for (v = 0; v < MAXVOICES; v++) {
					chkxpgrp(mll_p->u.staff_p->groups_p[v],
						mll_p->inputfile,
						mll_p->inputlineno);
				}
				return;
			}
			else if (mll_p->u.staff_p->staffno < s) {
				/* user must have increased the number of
				 * staffs as well, so the staff in question
				 * didn't exist in previous measure */
				return;
			}
		}
	}
}
\f

/* find the last group in a list of grpsyls. If it has any ties on it,
 * print warning message for trying to tie across a transposition, and discard
 * the tie(s). */

static void
chkxpgrp(gs_p, inputfile, lineno)

struct GRPSYL *gs_p;	/* check this grpsyl list */
char *inputfile;	/* for error message */
int lineno;

{
	register int n;		/* index through notelist */


	/* find last group in list */
	for (   ; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {

		if (gs_p->next == (struct GRPSYL *) 0) {
			/* this is the last group in the measure. See if
			 * it has any ties on it */
			for (n = 0; n < gs_p->nnotes; n++) {
				if (gs_p->notelist[n].tie == YES) {
					/* Aha! User tried to do a tie over
					 * a transpose */
					l_warning(inputfile, lineno,
					 	"can't tie into transposition change (use slur)");
					/* cancel any and all ties on this grp,
					 * and return, so we don't print more
					 * than one error per group */
					for (n = 0; n < gs_p->nnotes; n++) {
						gs_p->notelist[n].tie = NO;
					}
					gs_p->tie = NO;
					return;
				}
			}
		}
	}
}
\f

/* On tablature staffs, if two consecutive groups are tied together,
 * normally the frets are not printed for the second group, so we need
 * to set the inhibitprint flag on the group. However if there is any
 * reason why inhibiting printing on a given group isn't a good idea,
 * we won't set the inhibitprint flag. So this function checks all the
 * possible reasons for not setting inhibitprint, and if none of them
 * apply, then it is set.
 */

static void
set_inhibitprint_if_appropriate(gs_p, mll_p)

struct GRPSYL *gs_p;
struct MAINLL *mll_p;

{
	struct GRPSYL *nextgs_p;	/* the group after gs_p */
	struct GRPSYL *following_p;	/* the group after next_gs_p */
	int n;				/* index through notelist */
	


	if ((nextgs_p = nextgrpsyl(gs_p, &mll_p)) == (struct GRPSYL *) 0) {
		/* no next group, so nothing to set */
		return;
	}

	/* if this group and next group don't have same number of notes,
	 * then there won't be an inhibitprint on the next group */
	if (gs_p->nnotes == 0 || gs_p->nnotes != nextgs_p->nnotes) {
		return;
	}

	/* if next group has a "with" list, no inhibitprint */
	if (nextgs_p->nwith != 0) {
		return;
	}

	for (n = 0; n < gs_p->nnotes; n++) {
		/* if any notes in this group are not tied, then there won't be
		 * an inhibitprint on the next group */
		if (gs_p->notelist[n].tie == NO) {
			return;
		}

		/* if next group has any slides to/from nowhere, or slurs
		 * to the next group, it won't get inhibitprint set */
		if (nextgs_p->notelist[n].nslurto != 0) {
			return;
		}
	}

	/* next group has a bend of any sort, it doesn't get inhibitprint */
	for (n = 0; n < nextgs_p->nnotes; n++) {
		if (HASBEND(nextgs_p->notelist[n]) == YES) {
			return;
		}
	}
	
	/* if group following next group has a non-prebend bend, then the
	 * next group does not get inhibitprint */
	if ((following_p = nextgrpsyl(nextgs_p, &mll_p)) != (struct GRPSYL *) 0) {
		for (n = 0; n < following_p->nnotes; n++) {
			if (HASBEND(following_p->notelist[n]) == YES &&
					following_p->notelist[n].FRETNO == NOFRET) {
				return;
			}
		}
	}

	/* Whew! If we got here, the group passed all the tests to have its
	 * inhibitprint flag set, so set it */
	nextgs_p->inhibitprint = YES;
}