Import upstream version 5.3.

[mup] / mup / mup / map.c

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

/* This file contains functions for mapping input to individual voices.
 * The user can give a single line of input
 * that gets expanded into several voices.
 * There are two flavors of this:
 * voice-at-a-time input and chord-at-a-time input.
 * For the former, the GRPSYL list just gets cloned and altered as needed.
 * For the latter, brand new GRPSYL lists are created
 * by distributing individual notes from the user's input.
 * For any given staff/voice, only one type of input can be used per measure.
 * For chord-at-a-time, a given staff/voice can appear more than once
 * within a single input line, but not on multiple input lines per measure.
 */

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

/* mark whether we mapped user data, only mapped implicit spaces, or nothing */
#define MAPPED_NOTHING	(0)
#define MAPPED_IMPLICIT	(1)
#define MAPPED_EXPLICIT	(2)

/* This struct tells how to map one note for chord-at-a-time input,
 * i.e., which staff/voice combinations it should be mapped to.
 * Each map item in input (semicolon-separated)
 * gets saved in one of these. */
struct NOTEMAP {
	struct SVRANGELIST *svlist_p;	/* staffs/voices to map this note to */
	struct NOTEMAP *next;		/* linked list */
};

/* This struct gives the mapping for a particular number of notes.
 * The set of things inside a pair of brackets gets saved in one of these. */
struct MAP {
	int num_entries;		/* how many item in list */
	struct NOTEMAP *notemap_p;	/* one entry for each note in chord */
	struct MAP *next;		/* linked list */
};

/* This points to the list of maps, or to 0 if doing voice-at-a-time input */
static struct MAP *Map_p;
/* This points to where to add to the map list */
static struct MAP **End_map_p_p = &Map_p;

/* This is where to insert the next NOTEMAP */
static struct NOTEMAP **Note_p_p;

/* It is handy to be able to treat both input styles identically
 * as much as possible. So for when input is voice-at-a-time, it can be handy
 * to have a MAP that just points to Svrangelist_p. These two structs are
 * used for that purpose. Since the value of Svrangelist_p changes
 * at runtime, we have to set Sv_notemap->svlist_p each time
 * before these are used. */
static struct NOTEMAP Sv_notemap = {
	(struct SVRANGELIST *) 0, (struct NOTEMAP *) 0
};
static struct MAP Voice_at_a_time_map = {
	1, &Sv_notemap, (struct MAP *) 0
};

/* Keep track of which input style was used */
static short Input_style[MAXSTAFFS][MAXVOICES];

static int map_groups P((void));
static void clean_map_data P((void));
static void free_maps P((struct MAP *map_p));
static void free_notemaps P((struct NOTEMAP *notemap_p));
static struct NOTEMAP *find_notemap P((int num_notes));
static void map1note P((struct GRPSYL *from_gs_p, int n, int staff, int voice,
	short allocated[MAXSTAFFS][MAXVOICES]));
static void do_link_groups P((void));
static void link_a_grouplist P((int staffno, int vno, int copies));
static void convert_rest_space P((struct GRPSYL *grpsyl_p, int staffno, int vno));
static void conv_grpsyl P((struct GRPSYL *grpsyl_p, int staffno, int vno));
static void mult_def P((int staff, int voice));
\f

/* Initialize Input_style to default of IS_VOICE_INPUT */

void
reset_input_style()

{
	int staff;
	int voice;

	for (staff = 0; staff < MAXSTAFFS; staff++) {
		for (voice = 0; voice < MAXVOICES; voice++) {
			Input_style[staff][voice] = IS_VOICE_INPUT;
		}
	}
}
\f

/* Return the current input style for a given staff/voice */

int
input_style(staff, voice)

int staff;
int voice;

{
	return(Input_style[staff-1][voice-1]);
}
\f

/* This is called when a '[' is encountered in input, starting a new map */

void
begin_map()

{
	struct MAP *new_p;


	/* allocate space for a new map */
	CALLOC(MAP, new_p, 1);

	/* Keep track of where to link on the first NOTEMAP */
	Note_p_p = &(new_p->notemap_p);

	/* Add to MAP list */
	*End_map_p_p = new_p;

	begin_sv_list();
}
\f

/* Save one item of a map. Items are the semicolon-separated specifications. */

void
map_item()
{
	CALLOC(NOTEMAP, *Note_p_p, 1);

	/* Save the current range */
	(*Note_p_p)->svlist_p = Svrangelist_p;
	((*End_map_p_p)->num_entries)++;

	/* prepare for another, if any */
	Note_p_p = &( (*Note_p_p)->next);

	begin_sv_list();
	begin_range(PL_UNKNOWN);
}
\f

/* At the end of a map specification, this function is called to save the
 * info about the map for later use, and prepare for another map, if any.
 */

void
end_map()

{
	/* prepare for another map, if any */
	End_map_p_p = &( (*End_map_p_p)->next);

	begin_range(Place);
}
\f

/* Map chord-at-a-time input so it looks just like voice-at-a-time input.
 * Return YES if current measure is chord-at-a-time, and thus
 * mapping was done, NO if current measure is voice-at-a-time.
 */

static int
map_groups()

{
	struct MAP *map_p;
	/* Multiple notes in a chord might get mapped to a single staff/voice.
	 * In that case, after the first note for that staff/voice,
	 * we need to just add a note to the existing GRPSYL rather than
	 * allocating a new one. This keeps track of whether we have already
	 * allocated a GRPSYL for the current chord of a given staff/voice. */
	short allocated[MAXSTAFFS][MAXVOICES];
	/* This array tells us which staffs/voices we are mapping things to */
	short used[MAXSTAFFS][MAXVOICES];
	/* This array will have MAPPED_EXPLICIT
	 * in entries where we mapped actual user data.
	 * If we only mapped implicit spaces (MAPPED_IMPLICIT),
	 * we can treat things as if user didn't use the voice
	 * on this input line. */
	short mapped_something[MAXSTAFFS][MAXVOICES];
	/* This says if we've printed an error yet for multiply defined voice,
	 * to make sure we only print it once. */
	short printed_mult_err[MAXSTAFFS][MAXVOICES];
	/* This tells which numbers of notes we have maps for. */
	short have_map[MAXHAND];
	int s;			/* staff number */
	int v;			/* voice number */
	int n;			/* note index */
	struct NOTEMAP *notemap_p;	/* how to map notes to voices */
	struct SVRANGELIST *svr_p;
	struct RANGELIST *sr_p;	/* range of staffs being defined */
	struct RANGELIST *vr_p;	/* range of vno's being defined */
	struct GRPSYL *gs_p;
	struct GRPSYL *g_p;
	int errors;


	if (Map_p == (struct MAP *) 0) {
		/* not chord-at-a-time mapping, so nothing to do here */
		return(NO);
	}

	/* remember current error count */
	errors = Errorcount;

	/* Initialize arrays. These will later tell us
	 * which GRPSYL lists we are mapping to, and whether we mapped
	 * any actual user input, or just implicit spaces. */
	for (s = 0; s < Score.staffs; s++) {
		for (v = 0; v < MAXVOICES; v++) {
			used[s][v] = NO;
			mapped_something[s][v] = MAPPED_NOTHING;
			printed_mult_err[s][v] = NO;
		}
	}
	/* This tells for which numbers of notes we have maps */
	for (n = 0; n < MAXHAND; n++) {
		have_map[n] = NO;
	}

	/* Do some error checking on the MAP list */
	for (map_p = Map_p; map_p != (struct MAP *) 0; map_p = map_p->next) {

		if (have_map[map_p->num_entries] == YES) {
			l_yyerror(Curr_filename, yylineno,
				"more than one map for chords with %d notes",
				map_p->num_entries);
			continue;
		}
		else {
			have_map[map_p->num_entries] = YES;
		}

		for (notemap_p = map_p->notemap_p;
				notemap_p != (struct NOTEMAP *) 0;
				notemap_p = notemap_p->next) {
			for (svr_p = notemap_p->svlist_p;
					svr_p != (struct SVRANGELIST *) 0;
					svr_p = svr_p->next) {
			    for (sr_p = svr_p->stafflist_p; sr_p != 0;
							sr_p = sr_p->next) {
				for (s = sr_p->begin; s <= sr_p->end; s++) {

					if (s > Score.staffs) {
						l_yyerror(Curr_filename,
							yylineno,
							"staff %d does not exist",
							s);
						continue;
					}

					for (vr_p = svr_p->vnolist_p; vr_p != 0;
							vr_p = vr_p->next) {
					    for (v = vr_p->begin;
							v <= vr_p->end; v++) {

						/* make sure voice exists */
						if (v > 1 && svpath(s, VSCHEME)
							->vscheme == V_1) {
						   l_yyerror(Curr_filename,
							yylineno,
							"there is no voice %d on staff %d",
							v, s);
						}
						used[s-1][v-1] = YES;
						Input_style[s-1][v-1]
							= IS_CHORD_INPUT;
					    }
					}
				}
			    }
			}
		}
	}

	if (Errorcount > errors) {
		clean_map_data();
		return(YES);
	}

	/* process each chord in the GRPSYL list */
	for (gs_p = Curr_gs_list_p; gs_p != (struct GRPSYL *) 0;
							gs_p = gs_p->next) {
		/* initialize the allocation array for current chord */
		for (s = 0; s < Score.staffs; s++) {
			for (v = 0; v < MAXVOICES; v++) {
				allocated[s][v] = NO;
			}
		}

		/* With voice-at-a-time input, we allow the first group
		 * to have no pitch specified iff it is on a 1-line staff.
		 * For chord-at-a-time, to allow that
		 * we would have to allow a mapping of zero notes,
		 * which doesn't make sense, or map an implicit note,
		 * which seems questionable at best.
		 * If there is a mixture of 1-line and not-1-line
		 * staffs being mapped, things get even more confusing.
		 * So we disallow implicit pitch on chord-at-at-time. */
		if (gs_p->nnotes == 1 && gs_p->notelist[0].letter == PP_NO_PITCH) {
			l_yyerror(Curr_filename, yylineno, "no notes specified");
			notemap_p = (struct NOTEMAP *) 0;
		}
		else {
			/* Find the pattern matching the number of notes.
			 * If none is found, this will return 0, and the 'for'
			 * below will get skipped, and we'll add spaces */
			notemap_p = find_notemap(gs_p->nnotes);
		}

		/* Go through each note in the chord, and copy it
		 * to the appropriate staffs/voices */
		for (n = 0; notemap_p != (struct NOTEMAP *) 0;
					n++, notemap_p = notemap_p->next) {
			for (svr_p = notemap_p->svlist_p;
					svr_p != (struct SVRANGELIST *) 0;
					svr_p = svr_p->next) {
			    for (sr_p = svr_p->stafflist_p; sr_p != 0;
							sr_p = sr_p->next) {
				for (s = sr_p->begin; s <= sr_p->end; s++) {
				    for (vr_p = svr_p->vnolist_p; vr_p != 0;
							vr_p = vr_p->next) {
					for (v = vr_p->begin;
							v <= vr_p->end; v++) {
						/* If we have not yet mapped
						 * anything from the current
						 * input line, yet there is
						 * something in the grpsyl
						 * list for this staff/voice,
						 * that means user must have
						 * already defined data for
						 * this staff/voice on some
						 * other input line, and thus
						 * is not allowed to map
						 * anything from the current
						 * line. */
						if (mapped_something[s-1][v-1]
							== MAPPED_NOTHING
							&& Staffmap_p[s]->u.staff_p->groups_p[v-1] != 0
							&& printed_mult_err[s-1][v-1] == NO) {
						    mult_def(s, v);
						    printed_mult_err[s-1][v-1] = YES;
						    continue;
						}
						map1note(gs_p, n, s, v,
								allocated);
						mapped_something[s-1][v-1]
							= MAPPED_EXPLICIT;
					}
				    }
				}
			    }
			}
		}

		/* For any staff/voice that is being mapped to, but which
		 * didn't get anything mapped for this particular chord,
		 * add a space group. This could happen either because
		 * user specified several patterns and some patterns don't
		 * contain all the staffs/voices, which implies they want
		 * us to fill in spaces, or because there was an error in
		 * input. If there was an error, it's still nice to add the
		 * space, because it prevents extra error messages */
		for (s = 1; s <= Score.staffs; s++) {
			for (v = 1; v <= MAXVOICES; v++) {
				/* If we haven't mapped anything to this
				 * voice, but there is something there,
				 * user must have defined it on an earlier
				 * input line. In that case we should leave
				 * it be, because either (1) user didn't
				 * actually use any pattern that uses this
				 * voice, or (2) they multiply defined the
				 * voice, in which case the error is caught
				 * elsewhere. In either case, their
				 * earlier input should stand. */
				if (mapped_something[s-1][v-1] == MAPPED_NOTHING
						&& Staffmap_p[s]->u.staff_p->groups_p[v-1] != 0) {
					continue;
				}

				if (used[s-1][v-1] == YES &&
						allocated[s-1][v-1] == NO) {
					map1note(gs_p, -1, s, v, allocated);
					if (mapped_something[s-1][v-1] !=
							MAPPED_EXPLICIT) {
						mapped_something[s-1][v-1]
							= MAPPED_IMPLICIT;
					}
				}
			}
		}
	}

	/* If this particular input line didn't actually use some of the
	 * patterns, some voices might not *really* have been used--we
	 * merely filled in implicit spaces for it. So we can undo that
	 * so user can specify the voice via voice-at-a-time if they want to.
	 * If they don't, the regular filling in of missing voices with
	 * implicit spaces will happen later. */
	for (s = 0; s < Score.staffs; s++) {
		for (v = 0; v < MAXVOICES; v++) {
			if (used[s][v] == YES &&
					mapped_something[s][v] != MAPPED_EXPLICIT) {
				used[s][v] = NO;
				Input_style[s][v] = IS_VOICE_INPUT;

				/* If only implict, we free that up */
				if (mapped_something[s][v] == MAPPED_IMPLICIT) {
					free_grpsyls(Staffmap_p[s+1]->u.staff_p->groups_p[v]);
					Staffmap_p[s+1]->u.staff_p->groups_p[v] = 0;
				}
			}
		}
	}

	/* Now we can go through and free up any wasted space */
	for (s = 0; s < Score.staffs; s++) {
		for (v = 0; v < MAXVOICES; v++) {
			if (used[s][v] == YES) {
				/* Rests and spaces get moved from
				 * NOTE pseudo-pitches to GRPSYL */
				convert_rest_space(Staffmap_p[s+1]->u.
						staff_p->groups_p[v], s+1, v+1);
				for (g_p = Staffmap_p[s+1]->u.staff_p->groups_p[v];
						g_p != (struct GRPSYL *) 0;
						g_p = g_p->next) {
					resize_notelist(g_p);
				}
			}
		}
	}

	clean_map_data();

	/* Everything in the original GRPSYL list
	 * has been copied to other lists, so original can be freed */
	free_grpsyls(gs_p);

	return(YES);
}
\f

/* map one note to one staff/voice */

static void
map1note(from_gs_p, n, staff, voice, allocated)

struct GRPSYL *from_gs_p;	/* copy from here */
int n;				/* copy the nth note in from_gs_p, or if -1,
				 * create a space group */
int staff;
int voice;
short allocated[MAXSTAFFS][MAXVOICES];	/* tracks whether to allocate a new
				 * GRPSYL; may be updated */

{
	struct GRPSYL *to_gs_p;		/* where to map note to */
	struct GRPSYL **add_p_p;	/* where to add to_gs_p */
	struct NOTE *from_note_p;
	struct NOTE *to_note_p;
	struct GRPSYL *prev;		/* value to set to_gs_p->prev to */


	/* If original group is a grace group, we don't need to add a
	 * space group, since grace already take no time */
	if (n == -1 && from_gs_p->grpvalue == GV_ZERO) {
		return;
	}

	/* If this is the first note allocated to this staff/voice for
	 * current chord, have to allocate a GRPSYL for it. */
	if (allocated [staff - 1] [voice - 1] == NO) {
		to_gs_p = newGRPSYL(GS_GROUP);
		copy_attributes(to_gs_p, from_gs_p);
		/* by the time we get here, we've already gone past the
		 * newline, so the input line number is one too much */
		to_gs_p->inputlineno--;

		allocated [staff - 1] [voice - 1] = YES;

		/* Add to end of list */
		prev = (struct GRPSYL *) 0;
		for (add_p_p = &(Staffmap_p[staff]->u.staff_p->groups_p[voice-1]);
					*add_p_p != (struct GRPSYL *) 0;
					add_p_p = &((*add_p_p)->next) ) {
			prev = *add_p_p;
		}
		to_gs_p->prev = prev;
		*add_p_p = to_gs_p;

		/* copy the other attributes */
		to_gs_p->staffno = staff;
		to_gs_p->vno = voice;
		to_gs_p->basictime = from_gs_p->basictime;
		to_gs_p->fulltime = from_gs_p->fulltime;
		to_gs_p->dots = from_gs_p->dots;
		to_gs_p->is_meas = from_gs_p->is_meas;
		to_gs_p->tuploc = from_gs_p->tuploc;
		to_gs_p->tupcont = from_gs_p->tupcont;
		to_gs_p->tupside = from_gs_p->tupside;
		to_gs_p->beamloc = from_gs_p->beamloc;
		to_gs_p->breakbeam = from_gs_p->breakbeam;
		to_gs_p->beamto = from_gs_p->beamto;
		to_gs_p->printtup = from_gs_p->printtup;
		to_gs_p->tie = from_gs_p->tie;
		to_gs_p->inhibitprint = from_gs_p->inhibitprint;
		to_gs_p->ho_usage = from_gs_p->ho_usage;
		to_gs_p->ho_value = from_gs_p->ho_value;
	}
	else {
		/* find the last group for this staff/voice */
		for (to_gs_p = Staffmap_p[staff]->u.staff_p->groups_p[voice-1];
					to_gs_p->next != (struct GRPSYL *) 0;
					to_gs_p = to_gs_p->next) {
			;
		}
	}

	/* Special case: If n == -1, make this a space group */
	if (n == -1) {
		to_gs_p->grpcont = GC_SPACE;
		/* some things don't make sense with space,
		 * so nullify the things that just apply to notes */
		to_gs_p->grpvalue = GV_NORMAL;
		to_gs_p->headshape = HS_UNKNOWN;
		to_gs_p->grpsize = GS_NORMAL;
		to_gs_p->stemdir = UNKNOWN;
		to_gs_p->stemlen = STEMLEN_UNKNOWN;
		to_gs_p->roll = NOITEM;
		to_gs_p->beamloc = NOITEM;
		to_gs_p->breakbeam = NO;
		to_gs_p->beamto = CS_SAME;
		to_gs_p->stemto = CS_SAME;
		to_gs_p->slash_alt = 0;
		return;
	}

	from_note_p = &(from_gs_p->notelist[n]);
	if (Doing_tab_staff == YES) {
		/* fret, nticks, and bendstring exist in from_note_p
		 * in an internal format, whereas add_note() needs them
		 * in something close to user input format,
		 * so we have to reconstruct
		 * what the user input must have been. */
		add_note(to_gs_p, from_gs_p->notelist[n].letter,
			from_note_p->accidental,
			TMP_FRET(from_note_p),
			TMP_NTICKS(from_note_p),
			from_note_p->acc_has_paren,
			(HASBEND(from_gs_p->notelist[n])
			  ? bend_string(from_note_p)
			  : (char *) 0) );
	}
	else {
		add_note(to_gs_p, from_gs_p->notelist[n].letter,
			from_note_p->accidental,
			from_note_p->octave,
			0,
			from_note_p->acc_has_paren,
			(char *) 0);
	}

	/* copy remaining note attributes: tie, slur, etc */
	to_note_p = &(to_gs_p->notelist[to_gs_p->nnotes - 1]);
	to_note_p->tie = from_note_p->tie;
	to_note_p->tiestyle = from_note_p->tiestyle;
	to_note_p->tiedir = from_note_p->tiedir;
	to_note_p->nslurto = from_note_p->nslurto;
	if (from_note_p->nslurto > 0) {
		/* slurto lists cannot be safely shared, so make copy */
		MALLOC(SLURTO, to_note_p->slurtolist, 
					from_note_p->nslurto);
		(void) memcpy(to_note_p->slurtolist,
					from_note_p->slurtolist,
					sizeof(struct SLURTO) *
					from_note_p->nslurto);
	}
	else {
		to_note_p->slurtolist = (struct SLURTO *) 0;
	}
	to_note_p->notesize = from_note_p->notesize;
	to_note_p->note_has_paren = from_note_p->note_has_paren;
	to_note_p->is_bend = from_note_p->is_bend;
	to_note_p->smallbend = from_note_p->smallbend;
}
\f

/* When done with temporary map data, clean everything up, to prepare
 * for potentially getting another set of data */

static void
clean_map_data()

{
	/* free up the lists */
	free_maps(Map_p);

	/* reset pointers to be ready for more data */
	Map_p = (struct MAP *) 0;
	End_map_p_p = &Map_p;
}
\f

/* free up the MAP list and everything hanging off of it */

static void
free_maps(map_p)

struct MAP *map_p;

{
	if (map_p == (struct MAP *) 0) {
		/* end recursion */
		return;
	}

	/* free the list hanging off of this struct */
	free_notemaps(map_p->notemap_p);

	/* recurse */
	free_maps(map_p->next);

	/* free the passed-in struct */
	FREE(map_p);
}

/* free up a NOTEMAP list and everything hanging off of it */

static void
free_notemaps(notemap_p)

struct NOTEMAP *notemap_p;

{
	if (notemap_p == (struct NOTEMAP *) 0) {
		return;
	}

	free_sv_list(notemap_p->svlist_p);
	free_notemaps(notemap_p->next);
	FREE(notemap_p);
}
\f

/* Given a number of notes, find the NOTEMAP list for that many and return it.
 * If not found, return 0. */

static struct NOTEMAP *
find_notemap(num_notes)

int num_notes;

{
	struct MAP *m_p;

	for (m_p = Map_p; m_p != (struct MAP *) 0; m_p = m_p->next) {
		if (m_p->num_entries == num_notes) {
			return(m_p->notemap_p);
		}
	}
	
	l_yyerror(Curr_filename, yylineno,
			"there is no bracketed mapping for chords containing %d note%s", num_notes, num_notes == 1 ? "" : "s");
	return ((struct NOTEMAP *) 0);
}
\f

/* Once a measure-worth of data is gathered for one or more staffs/voices,
 * link copies onto the appropriate STAFF structs */

void
link_groups()

{
	/* if haven't yet set up the STAFFs for this measure, do so now */
	create_staffs();

	/* if we are in this function, user specified some music data */
	Got_some_data = YES;
	Got_group = YES;

	/* do error check--can't have notes and multirest in same measure */
	if (Got_multirest == 1) {
		report_mix_error();
		return;
	}

	/* Do either chord-to-voice-mapping or standard voice mapping,
	 * as appropriate. */
	if (map_groups() == NO) {
		do_link_groups();
	}

	/* re-initialize for next measure */
	Curr_gs_list_p = (struct GRPSYL *) 0;
	free_rlists();
}
\f

/* Go through Svrangelist, creating copies of the GRPSYL lists and
 * linking them to the appropriate STAFFs. */

static void
do_link_groups()

{
	struct SVRANGELIST *svr_p;	/* list of ranges of staffs and vnos */
	register int s;		/* staff index */
	register int v;		/* voice index */
	struct RANGELIST *sr_p;	/* range of staffs being defined */
	struct RANGELIST *vr_p;	/* range of vno's being defined */
	int copies = 0;		/* how many copies of grpsyl list made so far */


	for (svr_p = Svrangelist_p; svr_p != (struct SVRANGELIST *) 0;
						svr_p = svr_p->next) {

		for (sr_p = svr_p->stafflist_p; sr_p != (struct RANGELIST *) 0;
							sr_p = sr_p->next) {

			for (s = sr_p->begin; s <= sr_p->end; s++) {

				for (vr_p = svr_p->vnolist_p;
						vr_p != (struct RANGELIST *) 0;
						vr_p = vr_p->next) {

					for (v = vr_p->begin;
							v <= vr_p->end; v++) {
						link_a_grouplist(s, v, copies++);
					}
				}
			}
		}
	}
}
\f

/* connect list of GRPSYLs to a staff. If copies == 0, use the current
 * grpsyl list, otherwise make a copy of it and use the copy */

static void
link_a_grouplist(staffno, vno, copies)

int staffno;
int vno;
int copies;	/* if non-zero, need to make a copy */

{
	if (rangecheck(staffno, MINSTAFFS, Score.staffs, "staff number")
					== NO) {
		return;
	}

	if (rangecheck(vno, MINVOICES, MAXVOICES, "voice number") == NO) {
		return;
	}

	if (Staffmap_p[staffno] == (struct MAINLL *) 0) {
		return;
	}

	if (Staffmap_p[staffno]->u.staff_p == (struct STAFF *) 0) {
		pfatal("null staff pointer while linking group list");
	}

	if (Staffmap_p[staffno]->u.staff_p->groups_p[vno-1]
			!= (struct GRPSYL *) 0) {
		mult_def(staffno, vno);
		return;
	}

	/* the first time through, we can use the
	 * existing list. After that we need to
	 * make a clone of the list */
	if (copies == 0) {
		(Staffmap_p[staffno])->u.staff_p->groups_p[vno-1]
					= Curr_gs_list_p;
		convert_rest_space(Staffmap_p[staffno]->u.
					staff_p->groups_p[vno-1], staffno, vno);
	}
	else {
		(Staffmap_p[staffno])->u.staff_p->groups_p[vno-1]
					= clone_gs_list(Curr_gs_list_p, YES);
	}
}
\f

/* With chord-at-a-time input style, it is legal to have
 * a mixture of pitches, spaces, and rests. However, once
 * everything has been distributed to individual voices, we need to check
 * that there aren't still any mixtures, and convert the rest and
 * space pseudo-notes into rest and space groups. Some error checks
 * also get done that couldn't be done till after this conversion. */

static void
convert_rest_space(grpsyl_p, staffno, vno)

struct GRPSYL *grpsyl_p;
int staffno;
int vno;

{
	for (   ; grpsyl_p != (struct GRPSYL *) 0; grpsyl_p = grpsyl_p->next) {
		conv_grpsyl(grpsyl_p, staffno, vno);
	}
}
\f

/* Given a GRPSYL, convert all the rest and space
 * pseudo notes to groups and do related error checking */

static void
conv_grpsyl(grpsyl_p, staffno, vno)

struct GRPSYL *grpsyl_p;
int staffno;
int vno;

{
	int notes, rests, spaces, rpts;/* count how many of each in chord */
	int n;				/* index through notes */

	/* Count how many notes, rests, and spaces in the group */
	rests = spaces = notes = rpts = 0;
	for (n = 0; n < grpsyl_p->nnotes; n++) {
		if (grpsyl_p->notelist[n].letter == PP_REST) {
			rests++;
		}
		else if (grpsyl_p->notelist[n].letter == PP_SPACE) {
			spaces++;
		}
		else if (grpsyl_p->notelist[n].letter == PP_RPT) {
			rpts++;
		}
		else {
			notes++;
		}
	}

	/* Group may not mix space, rest, rpt, and notes */
	if (spaces > 0 && spaces != grpsyl_p->nnotes) {
		l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
			"staff %d voice %d: mixture of space and non-space",
			staffno, vno);
		return;
	}
	if (rests > 0 && rests != grpsyl_p->nnotes) {
		l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
			"staff %d voice %d: mixture of rest and non-rest",
			staffno, vno);
		return;
	}
	if (rpts > 0 && rpts != grpsyl_p->nnotes) {
		l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
			"staff %d voice %d: mixture of rpt and non-rpt",
			staffno, vno);
		return;
	}

	/* convert rest, space, and rpt pseudo-notes to groups */
	if (notes < grpsyl_p->nnotes) {
		if (rests > 0) {
			/* This is actually a rest group */
			grpsyl_p->grpcont = GC_REST;
			grpsyl_p->tie = NO;
			/* If entire group was marked cue, leave it that way.
			 * Otherwise, if multiple rests map to this group,
			 * grpsize should be the biggest of them.
			 * So initialize to small size,
			 * and if we find any normal size,
			 * set to normal and jump out of the loop. */
			if (grpsyl_p->grpsize != GS_SMALL) {
				grpsyl_p->grpsize = GS_SMALL;
				for (n = 0; n < grpsyl_p->nnotes; n++) {
					if (grpsyl_p->notelist[n].notesize == GS_NORMAL) {
	
						grpsyl_p->grpsize = GS_NORMAL;
						break;
					}
				}
			}
		}
		else if (spaces > 0) {
			/* This is actually a space group */
			grpsyl_p->grpcont = GC_SPACE;
			grpsyl_p->tie = NO;
			/* Uncompressibility was temporarily saved
			 * in octave, so move it now. If multiple spaces
			 * mapped to this group, if any of them are
			 * uncompressible, make the group uncompressible. */
			for (n = 0; n < grpsyl_p->nnotes; n++) {
				if (grpsyl_p->notelist[n].octave == YES) {
					grpsyl_p->uncompressible = YES;
					break;
				}
			}
		}
		else if (rpts > 0) {
			/* This is actually a rpt. Internally, that is stored
			 * as a note group with no notes (nnotes gets zeroed
			 * a few lines down from here). This should 
			 * already be notes but doesn't hurt to set again. */
			grpsyl_p->grpcont = GC_NOTES;
		}
		if (grpsyl_p->notelist[0].slurtolist != (struct SLURTO *) 0) {
			l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
					"can't have slur on rest, space, or rpt");
		}
		free_notelist(grpsyl_p);
		grpsyl_p->notelist = 0;
		grpsyl_p->nnotes = 0;
	}

	if (grpsyl_p->grpcont == GC_NOTES) {
		if (grpsyl_p->is_meas == YES && grpsyl_p->nnotes > 0) {
			l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
				"'m' can only be used with rest, space, or rpt, not notes");
			return;
		}
	}

	/* grace can only apply to notes */
	if (grpsyl_p->grpvalue == GV_ZERO && (grpsyl_p->grpcont != GC_NOTES ||
					grpsyl_p->nnotes == 0)) {
		l_yyerror(grpsyl_p->inputfile, grpsyl_p->inputlineno,
				"grace can only be used with notes");
	}
}
\f

/* If first group of a measure has no time value specified, we have to use
 * the default. This is complicated by the fact that the user could be 
 * defining mulitples staffs/voices at once. If they are, we need to make
 * sure that all of them have the same default. */

struct SSV *
get_dflt_timeunit_ssv()

{
	struct MAP *map_p;		/* list of maps */
	struct NOTEMAP *notemap_p;	/* list of notemaps per map */
	struct SVRANGELIST *svr_p;	/* list of staff/voice ranges */
	struct RANGELIST *sr_p;		/* list of staffs being defined */
	struct RANGELIST *vr_p;		/* list of voices being defined */
	int s;				/* staff number */
	int v;				/* voice */
	int got_one = NO;		/* YES if have found a dflt value */
	RATIONAL this_timeunit;		/* value for current staff/voice */
	RATIONAL dflt_timeunit;		/* the default time unit to use */
	struct SSV *tu_ssv_p;		/* SSV containing relevent timeunit */
	struct SSV *ref_ssv_p;		/* SSV we had checked on prev
					 * staff/voice being defined together */


	/* If doing voice-at-a-time input, use the special MAP for that case,
	 * otherwise use the Map_p */
	if (Map_p == (struct MAP *) 0) {
		map_p = &Voice_at_a_time_map;
		map_p->notemap_p->svlist_p = Svrangelist_p;
	}
	else {
		map_p = Map_p;
	}

	/* score value is the ultimate default */
	dflt_timeunit = Score.timeunit;
	tu_ssv_p = ref_ssv_p = &Score;

	/* check each map/notemap/svrangelist/svrange/staff/voice combination */
	for (   ; map_p != (struct MAP *) 0; map_p = map_p->next) {
	    for (notemap_p = map_p->notemap_p;
				notemap_p != (struct NOTEMAP *) 0;
				notemap_p = notemap_p->next) {
		for (svr_p = notemap_p->svlist_p;
					svr_p != (struct SVRANGELIST *) 0;
					svr_p = svr_p->next) {
		    for (sr_p = svr_p->stafflist_p;
						sr_p != (struct RANGELIST *) 0;
						sr_p = sr_p->next) {
			for (s = sr_p->begin; s <= sr_p->end; s++) {
			    for (vr_p = svr_p->vnolist_p;
						vr_p != (struct RANGELIST *) 0;
						vr_p = vr_p->next) {
				for (v = vr_p->begin; v <= vr_p->end; v++) {

				    /* find default timeunit for
				     * this staff/voice */
				    tu_ssv_p = vvpath(s, v, TIMEUNIT);
				    this_timeunit = tu_ssv_p->timeunit;

				    if (got_one == NO) {
					/* now we have one to
					 * compare against */
					dflt_timeunit = this_timeunit;
					ref_ssv_p = tu_ssv_p;
					got_one = YES;
				    }
				    else if ( NE(this_timeunit, dflt_timeunit)
						|| timelists_equal(
						tu_ssv_p->timelist_p,
						ref_ssv_p->timelist_p)
						== NO) {
					yyerror("timeunit value must be the same for all staffs being defined on the same input line");
				    }
				}
			    }
			}
		    }
		}
	    }
	}

	return(tu_ssv_p);
}
\f

/* Return YES if the given lists are equivalent, NO if they aren't. */

int
timelists_equal(list1_p, list2_p)

struct TIMELIST *list1_p;
struct TIMELIST *list2_p;

{
	for (   ; list1_p != 0 && list2_p != 0;
			list1_p = list1_p->next, list2_p = list2_p->next) {
		if ( NE(list1_p->fulltime, list2_p->fulltime) ) {
			return(NO);
		}
	}
	return((list1_p == 0 && list2_p == 0) ? YES : NO);
}
\f

/* Return YES if the current staff range is for all tablature staffs.
 * Return NO if not. If there are a mixture, this is an error, so print
 * a message. It still returns NO in this case, so if the user wanted tab,
 * they may get a lot of errors.  Oh well. After all, they did make an error.
 */ 

int
is_tab_range()

{
	struct MAP *map_p;
	struct NOTEMAP *notemap_p;
	struct SVRANGELIST *svr_p;
	struct RANGELIST *sr_p;
	int s;				/* staff number */
	int found_tab_staff = NO;
	int found_non_tab_staff = NO;

	/* If doing voice-at-a-time input, use the special MAP for that case,
	 * otherwise use the Map_p */
	if (Map_p == (struct MAP *) 0) {
		map_p = &Voice_at_a_time_map;
		map_p->notemap_p->svlist_p = Svrangelist_p;
	}
	else {
		map_p = Map_p;
	}

	/* check each map/notemap/svrangelist/svrange/staff/voice combination */
	for (   ; map_p != (struct MAP *) 0; map_p = map_p->next) {
		for (notemap_p = map_p->notemap_p;
				notemap_p != (struct NOTEMAP *) 0;
				notemap_p = notemap_p->next) {
			for (svr_p = notemap_p->svlist_p;
					svr_p != (struct SVRANGELIST *) 0;
					svr_p = svr_p->next) {
		    		for (sr_p = svr_p->stafflist_p;
						sr_p != (struct RANGELIST *) 0;
						sr_p = sr_p->next) {
					for (s = sr_p->begin; s <= sr_p->end; s++) {
						if (is_tab_staff(s) == YES) {
							found_tab_staff = YES;
						}
						else {
							found_non_tab_staff = YES;
						}
					}
				}
			}
		}
	}

	if (found_tab_staff == YES && found_non_tab_staff == YES) {
		yyerror("mixture of tab and non-tab staffs not allowed");
	}

	return(found_tab_staff);
}
\f

/* When two notes in a chord are duplicates from chord-at-a-time input,
 * we want to merge the notes, and get rid of the extra. This function will
 * change the value of gs_p->nnotes and the size of the notelist array. */

void
merge_dup_notes(gs_p, n)

struct GRPSYL *gs_p;	/* remove duplicate from here */
int n;			/* merge note n and n+1 into slot n, then remove
			 * the note in slot n+1 by moving any remaining
			 * notes down. */

{
	int i;
	int sn, sn1;		/* slurto index */
	struct NOTE *note_p, *extra_p;


	/* get shorter names for what we will use a lot */
	note_p = &(gs_p->notelist[n]);
	extra_p = &(gs_p->notelist[n+1]);
	/* Merge the data between the two as best we can.
	 * In general, if one has a "stronger" version of some attribute,
	 * go with that one. We check the second; if it is "stronger",
	 * force the result to that--if it was already set the same, fine--
	 * probably faster to just assign than check and maybe assign.
	 * If second wasn't stronger, go with whatever the first was. */

	/* If one is normal, one small, override the small */
	if (extra_p->notesize == GS_NORMAL) {
		note_p->notesize = GS_NORMAL;
	}

	/* If either has a tie, do a tie */
	if (extra_p->tie == YES) {
		note_p->tie = YES;
	}
	/* Consider normal tie the strongest, then dashed, then dotted */
	if (extra_p->tiestyle == L_NORMAL) {
		note_p->tiestyle = L_NORMAL;
	}
	else if (extra_p->tiestyle == L_DASHED &&
			note_p->tiestyle != L_NORMAL) {
		note_p->tiestyle = L_DASHED;
	}
	if ( (extra_p->tiedir == UP && note_p->tiedir == DOWN) ||
			(extra_p->tiedir == DOWN && note_p->tiedir == UP)) {
		/* It would be nice to allow both up and down tie,
		 * especially since we can do that for slurs,
		 * but we only support one tie per note. */
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"duplicate notes with opposite tie direction not allowed");
	}
	else if (extra_p->tiedir != UNKNOWN) {
		note_p->tiedir = extra_p->tiedir;
	}


	/* Parentheses around an accidental means "just in case you forgot..."
	 * which is weaker than no parentheses, so only use parentheses if
	 * both have it. */
	if (extra_p->acc_has_paren == NO) {
		note_p->acc_has_paren = NO;
	}
	/* Parentheses around a note generally means the note is optional.
	 * An optional merged with a non-optional, is non-optional. */
	if (extra_p->note_has_paren == NO) {
		note_p->note_has_paren = NO;
	}

	/* Sorry, we don't deal with incompatible bends */
	if (note_p->is_bend != extra_p->is_bend ||
			extra_p->smallbend != note_p->smallbend) {
		l_yyerror(gs_p->inputfile, gs_p->inputlineno,
			"duplicate notes with bend mismatch not allowed");
	}

	/* Slurs... If duplicate between the two slurto lists, just leave
	 * the one, but use strongest slurstyle. If there is one in the
	 * NOTE to be deleted but not in the one to keep, move it. */
	for (sn1 = 0; sn1 < extra_p->nslurto; sn1++) {
		for (sn = 0; sn < note_p->nslurto; sn++) {
			if (note_p->slurtolist[sn].letter ==
					extra_p->slurtolist[sn1].letter &&
					note_p->slurtolist[sn].slurdir ==
					extra_p->slurtolist[sn1].slurdir &&
					note_p->slurtolist[sn].octave ==
					extra_p->slurtolist[sn1].octave) {
				/* duplicate; just fix style if necessary */
				if (extra_p->slurtolist[sn1].slurstyle
								== L_NORMAL) {
					note_p->slurtolist[sn].slurstyle
							= L_NORMAL;
				}
				else if (extra_p->slurtolist[sn1].slurstyle
						== L_DASHED &&
						note_p->slurtolist[sn].slurstyle
						!= L_NORMAL) {
					note_p->slurtolist[sn].slurstyle
							= L_DASHED;
				}
				break;
			}
		}
		if (sn == note_p->nslurto) {
			/* wasn't on the list to keep, so add it */
			add_slurto(gs_p, extra_p->slurtolist[sn1].letter,
					extra_p->slurtolist[sn1].octave,
					sn,
					extra_p->slurtolist[sn1].slurstyle);
		}
	}

	/* Move things down in the notelist to remove the extra */
	for (i = n + 1; i < gs_p->nnotes - 1; i++) {
		gs_p->notelist[i] = gs_p->notelist[i+1];
	}
	(gs_p->nnotes)--;
	REALLOC(NOTE, gs_p->notelist, gs_p->nnotes);
}
\f

/* print error message for multiply defined voice */

static void
mult_def(staff, voice)

int staff;
int voice;

{
	l_yyerror(Curr_filename, yylineno,
		"staff %d voice %d multiply defined (first defined on line %d)",
		staff, voice,
		Staffmap_p[staff]->u.staff_p->groups_p[voice-1]->inputlineno);
}