Merge branch 'arkkra' into shiny

[mup] / mup / mup / parstuff.c

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

/* parser functions related to STUFF */


#include <string.h>
#include "defines.h"
#include "structs.h"
#include "globals.h"

/* if user specifies a "til" clause on stuff with a number of measures > 0,
 * we need to save away info about where the til clause will end, to make sure
 * that it doesn't fall off the end of the measure or the piece. This is the
 * struct we use to save this info. */
static struct TIL_INFO {
	char	*inputfile;	/* where STUFF was defined */
	int	inputlineno;	/* where STUFF was defined */
	int	measnum;	/* number of measure in which til clause ends */
	float	count;		/* count in measure where til clause ends */
	struct TIL_INFO *next;	/* for linked list */
} *Til_info_list_p;

/* info about the STUFF currently being collected from input */
static int Curr_stuff_type;	/* ST_* */
static int Stuff_size;		/* point size of stuff text string */
static int Modifier;		/* TM_* for text, L_* for phrase */
static int Measnum = 1;		/* to check til clauses. Can't use Meas_num
				 * global because it doesn't count invisible
				 * bars but til clauses do */
static int Multi_adjust;	/* adjustment to Measnum to account
				 * for multirests */

/* head and tail of list of STUFF currently being collected from input */
static struct STUFF *Head_stufflist_p;
static struct STUFF *Tail_stufflist_p;

/* current pedal state for each staff. YES if in the middle of doing pedal,
 * NO if not. */
static short Pedal_state[MAXSTAFFS + 1];
static char *Ped_begin_str;	/* will point to "\(begped)" */
static char *Ped_up_down_str;	/* will point to "\(pedal)" */

/* static functions */
static struct STUFF *clone_stufflist P((struct STUFF *stufflist_p,
			int staffno, int all));
static void do_attach P((int staffno, int all, struct RANGELIST *vno_range_p));
static void midi_attach P((int staffno, struct STAFF *staff_p,
			struct RANGELIST *vno_range_p, int all));
static void free_stufflist P((struct STUFF *stuff_P));
static void free_tils P((struct TIL_INFO *til_p));
static void fix_pedal P((int staffno, struct STUFF *stuff_p));
static void ped_order_chk P((void));
\f

/* save current stuff type value. Also check that we are in data (music)
 * context */

void
set_stuff_type(stuff_type)

int stuff_type;

{
	Curr_stuff_type = stuff_type;

	(void) contextcheck(C_MUSIC, "statement");
}
\f

/* return current stuff type */

int
get_stuff_type()

{
	return(Curr_stuff_type);
}
\f

/* check all the things in an input line of stuff, up to the colon,
 * for consistency, and save interesting info away for later use. */

void
chk_stuff_header(size, modifier, place, dist_usage)

int size;		/* point size, or -1 if to use default */
int modifier;		/* TM_* for text, L_* for phrase */
int place;		/* PL_* */
int dist_usage;		/* SD_* */

{

	debug(4, "chk_stuff_header");

	switch (Curr_stuff_type) {
	case ST_ROM:
	case ST_BOLD:
	case ST_ITAL:
	case ST_BOLDITAL:
	case ST_MUSSYM:
		break;
	case ST_PEDAL:
		if (place != PL_BELOW && place != PL_UNKNOWN) {
			yyerror("pedal must be below");
		}
		/*FALLTHRU*/
	default:
		if (size != -1) {
			yyerror("can't specify size except with a font or mussym");
		}
		if (modifier != TM_NONE && Curr_stuff_type != ST_PHRASE) {
			l_yyerror(Curr_filename, yylineno,
					"can't specify %s except with a font",
					stuff_modifier(modifier));
		}
		if (Curr_stuff_type == ST_PHRASE && modifier != L_NORMAL &&
				modifier != L_DOTTED && modifier != L_DASHED) {
			l_yyerror(Curr_filename, yylineno,
					"only dotted or dashed line type can be specified for phrase");
		}
		break;
	}

	if (Curr_stuff_type == ST_OCTAVE) {
		if (is_tab_range() == YES) {
			yyerror("octave not allowed on tablature staff");
		}
		else if(place == PL_BETWEEN) {
			yyerror("octave must be above or below");
			place = PL_ABOVE;
		}
	}

	if (Curr_stuff_type == ST_PHRASE && place == PL_BETWEEN) {
		yyerror("phrase must be above, below, or omitted");
		place = PL_ABOVE;
	}

	if (dist_usage != SD_NONE) {
		if (Curr_stuff_type == ST_PEDAL) {
			yyerror("dist not allowed on pedal");
		}
		else if (Curr_stuff_type == ST_PHRASE) {
			yyerror("dist not allowed on phrase");
		}
		else if (Curr_stuff_type == ST_MIDI) {
			yyerror("dist not allowed on midi");
		}

		if (place == PL_BETWEEN) {
			yyerror("dist not allowed with 'between'");
		}
	}

	/* Save the modifier value.
	 * Have to set this before calling dflt_place() */
	Modifier = modifier;

	/* fill in default values if user didn't specify */
	if (place == PL_UNKNOWN) {
		place = dflt_place();
	}

	Stuff_size = size;
	Place = (short) place;

	/* make sure current list of stuff is empty */
	Head_stufflist_p = Tail_stufflist_p = (struct STUFF *) 0;
}
\f

/* return default value for place depending on value of Curr_stuff_type */

int
dflt_place()

{
	switch (Curr_stuff_type) {

	case ST_PEDAL:
		return(PL_BELOW);

	case ST_OCTAVE:
		yyerror("must specify above or below with octave");
		/* arbitrarily return above. If we leave it as unknown,
		 * we can get double error messages in some cases */
		return(PL_ABOVE);

	case ST_PHRASE:
		/* stays unknown at this point */
		return(PL_UNKNOWN);

	default:
		if (Modifier == TM_ANALYSIS || Modifier == TM_FIGBASS) {
			return(PL_BELOW);
		}
		/* default for everything else is above */
		return(PL_ABOVE);
	}
}
\f

/* Add a space padding to a string (except if is it boxed).
 * If padding was added, free the passed-in string and return the padded string,
 * else return the string as is. The incoming string
 * is expected to already be converted to font/size/string
 * internal format by this time, although still in input ASCII form.
 */

char *
pad_string(string, modifier)

char *string;
int modifier;	/* TM_* */

{
	char *padded_string;		/* string with 1-space padding at end */
	char *str_p;			/* walk through padded_string */
	int len;			/* length of string */
	int last_was_backslash;		/* YES/NO */
	int count_backslashed;		/* YES/NO if to count backslashed or
					 * unbackslashed colons */
	int colons;			/* how many colons found */
	int extra;			/* how many extra bytes to malloc */

	/* Boxed and circled strings don't get any extra padding,
	 * so we can use what we have */
	if (string[2] == '\\' && (string[3] == '[' || string[3] == '{')) {
		return(string);
	}

	/* Make a new copy with a space at the end.
	 * But if the string ends in the middle of a pile,
	 * we need to implicitly end the pile before adding the space.
	 * Since the string is still in ASCII form,
	 * we have to count up the number of colons
	 * to see if we are mid-pile. In chord/analysis/figbass
	 * we need to count unbackslashed colon,
	 * otherwise backslashed.*/
	count_backslashed = (IS_CHORDLIKE(modifier) ? NO : YES);
	/* figbass implicitly begins with a pile */
	colons = (modifier == TM_FIGBASS ? 1 : 0);
	last_was_backslash = NO;
	for (str_p = string + 2; *str_p != '\0'; str_p++) {
		if (last_was_backslash == YES) {
			if (*str_p == ':' && count_backslashed == YES) {
				colons++;
			}
			last_was_backslash = NO;
		}
		else {
			if (*str_p ==  ':' && count_backslashed == NO) {
				colons++;
			}
			last_was_backslash = (*str_p == '\\' ? YES : NO);
		}
	}

	/* If odd number of colons, we are mid-pile.  Will need
	 * add extra byte to hold the colon to implicitly end the
	 * pile, and if it needs to be a backslashed colon,
	 * another extra byte for that. */
	if (colons & 1) {
		extra = (count_backslashed == YES ? 2 : 1);
	}
	else {
		extra = 0;
	}

	len = strlen(string);

	/* +2 is for space/null at end */
	MALLOCA(char, padded_string, len + 2 + extra);
	(void) memcpy(padded_string, string, len);
	str_p = padded_string + len;

	/* add implicit end-pile if needed */
	if (extra == 2) {
		*str_p++ = '\\';
	}
	if (extra > 0) {
		*str_p++ = ':';
	}

	/* now add space padding */
	*str_p++ = ' ';
	*str_p = '\0';
	FREE(string);
	return(padded_string);
}
\f

/* check a "stuff" item  and add to list */

void
add_stuff_item(start_count, start_steps, gracebackup, string, bars, count,
		dist, dist_usage)

double start_count;		/* where in measure to start this stuff */
double start_steps;		/* offset by this many stepsizes */
int gracebackup;	/* how many grace notes to back up from start */
char *string;		/* what to print */
int bars;		/* how many bar lines to cross with this stuff */
double count;		/* how many beats into last measure */
int dist;		/* dist for this specific STUFF, to override param */
int dist_usage;		/* meaning of dist, SD_*  */

{
	struct STUFF *new_p;		/* where to store STUFF */
	struct TIL_INFO *til_info_p;	/* to save info about til clause */
	int len;			/* length of stuff text string */
	char *padded_string;		/* string with 1-space padding at end */
	char lch;			/* last character of string */


	if (bars != 0 || count != 0.0) {
		/* has a "til" clause. Check if that is valid */
		if (Curr_stuff_type == ST_MUSSYM) {
			if (string == (char *) 0) {
				yyerror("missing string");
				return;
			}

			/* not yet changed to internal form, need to compare
			 * in ASCII form */
			if ((strcmp(string + 2, "tr") != 0) &&
					(strcmp(string + 2, "\\(tr)") != 0)) {
				yyerror("til not allowed on mussym except on trills");
			}
		}

		else if (Curr_stuff_type == ST_PEDAL) {
			yyerror("til not allowed on pedal");
		}

		else if (Curr_stuff_type == ST_MIDI) {
			yyerror("til not allowed on midi");
		}

		if (Curr_stuff_type != ST_PHRASE &&
			(Modifier == TM_CHORD || Modifier == TM_ANALYSIS) ) {
			l_yyerror(Curr_filename, yylineno,
					"til not allowed with %s",
					stuff_modifier(Modifier));
		}

		if (bars == 0) {
			if (count > Score.timenum + 1) {
				yyerror("'til' value must be <= numerator of time signature + 1");
			}

			if (count < start_count) {
				yyerror("til value must be >= start value");
			}
		}

	}
	else {
		/* doesn't have a "til" clause. Check if one is required */
		if (Curr_stuff_type == ST_CRESC ||
						Curr_stuff_type == ST_DECRESC) {
			yyerror("til required on cresc/decresc");
		}
	}
	
	if (start_count > Score.timenum + 1) {
		yyerror("beat offset must be <= numerator of time signature + 1");
	}

	if (Curr_stuff_type == ST_CRESC || Curr_stuff_type == ST_DECRESC) {
		if (string != (char *) 0) {
			yyerror("string not allowed with cresc/decresc");
		}
		Modifier = TM_DYN;
	}

	else if (Curr_stuff_type == ST_PHRASE) {
		if (string != (char *) 0) {
			yyerror("string not allowed with phrase");
		}
	}

	else if (Curr_stuff_type == ST_PEDAL) {
		if ( (string != (char *) 0)
				&& (strcmp(string + 2, "\\(endped)") != 0) ) {
			yyerror("pedal string must be either blank or *");
		}
	}

	else {
		if (string == (char *) 0) {
			yyerror("string is required");
			return;
		}
	}

	if (gracebackup != 0 && Place == PL_BETWEEN) {
		yyerror("grace backup not allowed with 'between'");
	}

	/* we can't deal with step offset on phrase marks very well,
	 * so warn and ignore if we get one */
	if (start_steps != 0.0 && Curr_stuff_type == ST_PHRASE) {
		l_warning(Curr_filename, yylineno, "step offset ignored on phrase mark");
		start_steps = 0.0;
	}

	switch (Curr_stuff_type) {
	case ST_ROM:
	case ST_BOLD:
	case ST_ITAL:
	case ST_BOLDITAL:
		/* the text-type stuffs are supposed to have a 1-space padding
		 * at the end of them */
		if (bars != 0 || count != 0.0) {
			/* don't add padding if has wavy or solid line
			 * til clause */
			lch = last_char(string);
			if (lch == '~' || lch == '_') {
				break;
			}
		}
		string = pad_string(string, Modifier);
		break;

	case ST_MUSSYM:
		/* in mussym, user can specify things without the usual
		 * \(---) convention. Change to include them */
		if (string[2] == '\\' && string[3] == '(') {
			/* if user unnecessarily put in the \(--), leave it */
			break;
		}

		len = strlen(string + 2);
		MALLOCA(char, padded_string, len + 6);
		(void) sprintf(padded_string, "%c%c\\(%s)", FONT_TR, DFLT_SIZE,
						string + 2);
		FREE(string);
		string = padded_string;
		break;

	default:
		break;
	}

	/* fill in a new STUFF struct with appropriate info */
	new_p = newSTUFF(string, dist, dist_usage, start_count, start_steps,
		gracebackup, bars, count,
		Curr_stuff_type, Modifier, Place, Curr_filename, yylineno);

	/* if bars > 0, need to save away til info for later error
	 * checking */
	if (bars > 0) {
		CALLOC(TIL_INFO, til_info_p, 1);
		til_info_p->measnum = Measnum + bars;
		til_info_p->count = count;
		til_info_p->inputfile = new_p->inputfile;
		til_info_p->inputlineno = new_p->inputlineno;
		til_info_p->next = Til_info_list_p;
		Til_info_list_p = til_info_p;
	}

	/* above/between go on the head of the list, below goes on the
	 * tail of the list, so that things come out in the right order.
	 * Midi always goes at the end */
	if (Place == PL_BELOW || Curr_stuff_type == ST_MIDI) {
		/* link onto list tail */
		if ( Tail_stufflist_p == (struct STUFF *) 0) {
			Head_stufflist_p = new_p;
		}
		else {
			Tail_stufflist_p->next = new_p;
		}
		Tail_stufflist_p = new_p;
	}
	else {
		/* link onto head of list */
		new_p->next = Head_stufflist_p;
		Head_stufflist_p = new_p;
		if (Tail_stufflist_p == (struct STUFF *) 0) {
			Tail_stufflist_p = new_p;
		}
	}
}
\f

/* return YES if given string consists entirely of the specific music symbol */
/* the string should be in the internal format of font/size/string */

int
string_is_sym(string, sym, symfont)

char *string;	/* which string to check */
int sym;	/* check for this music symbol */
int symfont;	/* FONT_MUSIC*  */

{
	int font, size;


	if (string == (char *) 0) {
		return(NO);
	}

	font = *string++;
	size = *string++;
	if (next_str_char(&string, &font, &size) != sym) {
		return(NO);
	}
	if (font != symfont) {
		return(NO);
	}
	if (next_str_char(&string, &font, &size)  == '\0') {
		return(YES);
	}
	return (NO);
}
\f

/* connect a list of STUFF to a STAFF. If there is already something on
 * that STAFF's STUFF list, attach at the end or beginning as appropriate
 * depending on place. */

void
attach_stuff()

{
	struct SVRANGELIST *svr_p;	/* to walk through Svrangelist */
	struct RANGELIST *r_p;		/* to walk through staff range list */
	short staffno;


	debug(4, "attach_stuff");

	/* make sure we've got STAFF structs for this measure */
	create_staffs();

	for (svr_p = Svrangelist_p; svr_p != (struct SVRANGELIST *) 0;
						svr_p = svr_p->next) {
		for (r_p = svr_p->stafflist_p; r_p != (struct RANGELIST *) 0;
						r_p = r_p->next) {
	
			for (staffno = r_p->begin; staffno <= r_p->end
					&& staffno <= MAXSTAFFS; staffno++) {
				do_attach(staffno, r_p->all, svr_p->vnolist_p);

				if (Place == PL_BETWEEN) {
					/* between has 2 staffs in its range,
					 * but stuff is only associated
					 * with the top staff */
					break;
				}
			}
		}
	}

	free_rlists();

	/* have made copies of stuff for each staff that gets one, with
	 * the proper font/size etc, so need to free master stufflist copy */
	free_stufflist(Head_stufflist_p);
}
\f

/* Attach STUFF for a specific staff. */

static void
do_attach(staffno, all, vno_range_p)

int staffno;
int all;
struct RANGELIST *vno_range_p;

{
	struct STAFF *staff_p;		/* where to attach STUFF */
	struct STUFF *stufflist_p;	/* current copy of STUFF list */


	if (staffno > Score.staffs) {
		l_yyerror(Head_stufflist_p->inputfile,
				Head_stufflist_p->inputlineno,
				"staff number out of range");
		return;
	}

	staff_p = Staffmap_p[staffno]->u.staff_p;

	if (Place == PL_BETWEEN) {
		if (staffno + 1 > Score.staffs) {
			/* will have already exclaimed about
			 * this error before, so no need to print message,
			 * but better skip next check */
			return;
		}

		/* if either staff of a between is invisible,
		 * throw this stuff away */
		if (svpath(staffno, VISIBLE)->visible == NO ||
				svpath(staffno + 1,
				VISIBLE)->visible == NO) {
			return;
		}
	}

	/* handle MIDI stuff specially */
	if (Curr_stuff_type == ST_MIDI) {
		if (all == YES) {
			/* need to find top visible staff/voice to attach to */
			int s;		/* staff number */
			int v;		/* voice number */
			struct RANGELIST range;
	
			v = 1;	/* avoid bogus "used before set" warning */
			for (s = 1; s <= MAXSTAFFS; s++) {
				if (svpath(s, VISIBLE)->visible == YES) {
					for (v = 1; v <= MAXVOICES; v++) {
						if (vvpath(s, v, VISIBLE)->visible == YES) {
							break;
						}
					}
					if (v <= MAXVOICES) {
						break;
					}
				}
			}
			if (s > MAXSTAFFS || v > MAXVOICES) {
				pfatal("failed to find top visible staff/voice");
			}
			/* make a special RANGELIST for this */
			range.begin = range.end = v;
			range.all = YES;
			range.next = 0;
			midi_attach(s, Staffmap_p[s]->u.staff_p, &range, all);
		}
		else {
			midi_attach(staffno, staff_p, vno_range_p, all);
		}
	}

	else {
		/* make the copy for this staff from master copy */
		stufflist_p = clone_stufflist(Head_stufflist_p, staffno, all);

		if (Curr_stuff_type == ST_PEDAL) {
			fix_pedal(staffno, stufflist_p);
		}

		connect_stuff(staff_p, stufflist_p);
	}
}
\f

/* attach MIDI stuff. This is slightly different than other stuff because
 * it can be applied to one or both voices. */

static void
midi_attach(staffno, staff_p, vno_range_p, all)

int staffno;		/* attach to this staff number */
struct STAFF *staff_p;	/* attach to this staff struct */
struct RANGELIST *vno_range_p;
int all;		/* if associated with "all" */

{
	struct RANGELIST *r_p;		/* walk through vno_range_p */
	int vno;			/* voice number */
	struct STUFF *stufflist_p;	/* copy of stuff */
	struct STUFF *st_p;		/* walk through stufflist_p */
	short place;


	/* do for each voice that MIDI stuff applies to */
	for (r_p = vno_range_p; r_p != (struct RANGELIST *) 0; r_p = r_p->next) {
		for (vno = r_p->begin; vno <= r_p->end; vno++) {

			/* make the copy for this staff from master copy */
			stufflist_p = clone_stufflist(Head_stufflist_p,
						staffno, all);

			/* fix up place based on voice number */
			switch (vno) {
			case 1:
				place = PL_ABOVE;
				break;
			case 2:
				place = PL_BELOW;
				break;
			case 3:
				place = PL_BETWEEN;
				break;
			default:
				pfatal("illegal vno for midi");
				/*NOTREACHED*/
				place = PL_UNKNOWN;  /* avoid "used before set" warning */
				break;
			}
			for (st_p = stufflist_p; st_p != (struct STUFF *) 0;
						st_p = st_p->next) {
				st_p->place = place;
			}

			connect_stuff(staff_p, stufflist_p);
		}
	}
}
\f

/* connect a new stuff list into an existing stuff list. Add below stuff and
 * MIDI stuff to the end of the list,
 * and others to beginning of list, but make sure any
 * "above all" comes after any above non-all, and that any below non-all
 * comes before any "below all."
 */

void
connect_stuff(staff_p, stufflist_p)

struct STAFF *staff_p;		/* connect to stuff off of this staff */
struct STUFF *stufflist_p;	/* connect this list  of stuff */

{
	struct STUFF *st_p;		/* to find link place in STUFF list */
	struct STUFF *s_p;		/* to find end of stufflist_p */
	struct STUFF **ins_p_p;		/* where to insert in list */


	if (staff_p == (struct STAFF *) 0 || stufflist_p == (struct STUFF *) 0) {
		return;
	}

	if (staff_p->stuff_p == (struct STUFF *) 0) {
		/* no list before, so attach this one
		 * directly to STAFF */
		staff_p->stuff_p = stufflist_p;
	}

	else if (Place == PL_BELOW || stufflist_p->stuff_type == ST_MIDI) {
		/* if this set of stuff isn't associated with
		 * "all", then it goes before any below "all" stuff */
		if (stufflist_p->all == NO) {
			for (ins_p_p = &(staff_p->stuff_p); 
					*ins_p_p != (struct STUFF *) 0;
					ins_p_p = &((*ins_p_p)->next)) {
				if ( (*ins_p_p)->place == PL_BELOW &&
						(*ins_p_p)->all == YES) {
					break;
				}
			}
			/* find end of list to be inserted */
	 		for (s_p = stufflist_p; s_p->next != (struct STUFF *) 0;
							s_p = s_p->next) {
		    		;
			}

			/* insert */
			s_p->next = *ins_p_p;
			*ins_p_p = stufflist_p;
		}

		else {
			/* goes at end of list. find the end */
			for (st_p = staff_p->stuff_p;
					st_p->next != (struct STUFF *)0;
					st_p = st_p->next) {
				;
			}

			/* connect in the new list */
			st_p->next = stufflist_p;
		}
	}
	else {
		/* find end of new list */
		for (s_p = stufflist_p;
				s_p->next != (struct STUFF *) 0;
				s_p = s_p->next) {
			;
		}

		if (stufflist_p->all == NO) {
			/* goes at the head of the list */
			s_p->next = staff_p->stuff_p;
			staff_p->stuff_p = stufflist_p;
		}
		else {
			/* goes before any existing above all */
			for (ins_p_p = &(staff_p->stuff_p); 
					*ins_p_p != (struct STUFF *) 0;
					ins_p_p = &((*ins_p_p)->next)) {
				if ( (*ins_p_p)->place == PL_ABOVE &&
						(*ins_p_p)->all == YES) {
					break;
				}
			}
			/* find end of list to be inserted */
	 		for (s_p = stufflist_p; s_p->next != (struct STUFF *) 0;
							s_p = s_p->next) {
		    		;
			}

			/* insert */
			s_p->next = *ins_p_p;
			*ins_p_p = stufflist_p;
		}
	}
}
\f

/* given a list of STUFF, return a clone of the list */

static struct STUFF *
clone_stufflist(stufflist_p, staffno, all)

struct STUFF *stufflist_p;	/* what stuff to clone */
int staffno;			/* which staff, to get proper point size */
int all;			/* YES if was "above all" or "below all" */

{
	struct STUFF *new_p;	/* copy of STUFF */
	char *newstring;	/* copy of text string */
	int font;
	int fontfamily;
	int size;


	if (stufflist_p == (struct STUFF *) 0) {
		return( (struct STUFF *) 0 );
	}

	/* make copy of string with appropriate font and size */
	if (stufflist_p->string != (char *) 0) {
		switch(stufflist_p->stuff_type) {
		case ST_BOLD:
			font = FONT_TB;
			break;
		case ST_OCTAVE:
			Stuff_size = DFLT_SIZE;
			font = FONT_TI;
			break;
		case ST_ITAL:
			font = FONT_TI;
			break;
		case ST_BOLDITAL:
			font = FONT_TX;
			break;
		default:
			font = FONT_TR;
			break;
		}

		/* figure out the proper size if not already determined */
		if (Stuff_size  < 0) {
			if (all == YES) {
				size = Score.size;
			}
			else {
				size = svpath(staffno, SIZE)->size;
			}
		}
		else {
			size = Stuff_size;
		}

		/* determine fontfamily and font if not already known */
		if (Curr_family == FAMILY_DFLT) {
			if (all == YES) {
				fontfamily = Score.fontfamily;
			}
			else {
				fontfamily = svpath(staffno, FONTFAMILY)->
							fontfamily;
			}
		}
		else {
			fontfamily = Curr_family;
		}

		/* clone text string */
		newstring = copy_string(stufflist_p->string + 2, font, size);
		if (IS_CHORDLIKE(Modifier)) {
			newstring = modify_chstr(newstring, Modifier);
		}
		fix_string(newstring, fontfamily + font, size,
			stufflist_p->inputfile, stufflist_p->inputlineno);
		if (Modifier == TM_FIGBASS || Modifier == TM_ANALYSIS) {
			newstring = acc_trans(newstring);
		}
	}
	else {
		newstring = (char *) 0;
	}
	
	/* create and fill in clone of stuff, then return it */
	new_p = newSTUFF(newstring, stufflist_p->dist,
				stufflist_p->dist_usage,
				stufflist_p->start.count,
				stufflist_p->start.steps,
				stufflist_p->gracebackup,
				stufflist_p->end.bars, stufflist_p->end.count,
				stufflist_p->stuff_type, stufflist_p->modifier,
				stufflist_p->place, stufflist_p->inputfile,
				stufflist_p->inputlineno);
	new_p->all = (short) all;
	new_p->next = clone_stufflist(stufflist_p->next, staffno, all);
	return(new_p);
}
\f

/* allocate a STUFF and fill in all the values given. Initialize carry fields
 * and "all" to NO. Leave coordinates and next link as 0.
 * Note that the string pointer
 * is copied; it does not make a copy of the string itself, so never call this
 * function more than once with the same string--make a copy. */

struct STUFF *
newSTUFF(string, dist, dist_usage, start_count, start_steps, gracebackup, bars, count,
		stuff_type, modifier, place, inputfile, inputlineno)

char *string;		/* text string of stuff */
int dist;		/* dist for this STUFF to override dist parameter */
int dist_usage;		/* meaning of dist, SD_* */
double start_count;	/* count at which to begin stuff */
double start_steps;	/* offset by this many steps */
int gracebackup;	/* how many grace notes to back up from start */
int bars;		/* bars in "til" clasue */
double count;		/* counts in "til" clause */
int stuff_type;		/* ST_* */
int modifier;		/* TM_* */
int place;		/* PL_* */
char *inputfile;	/* which file stuff was defined in */
int inputlineno;	/* where stuff was defined in input file */

{
	struct STUFF *new_p;	/* the new STUFF to fill in */


	CALLOC(STUFF, new_p, 1);
	new_p->string = string;
	new_p->start.count = start_count;
	new_p->start.steps = start_steps;
	new_p->gracebackup = (short) gracebackup;
	new_p->dist = (short) dist;
	new_p->dist_usage = (short) dist_usage;
	new_p->end.bars = (short) bars;
	new_p->end.count = count;
	new_p->stuff_type = (short) stuff_type;
	new_p->modifier = (short) modifier;
	new_p->place = (short) place;
	new_p->carryin = new_p->carryout = new_p->all = NO;
	new_p->costuff_p = 0;
	new_p->inputfile = inputfile;
	new_p->inputlineno = (short) inputlineno;

	return(new_p);
}
\f

/* recursively free up a stufflist and any strings hanging off of it */

static void
free_stufflist(stuff_p)

struct STUFF *stuff_p;

{
	if (stuff_p == (struct STUFF *) 0 ) {
		return;
	}

	free_stufflist(stuff_p->next);
	if (stuff_p->string != (char *) 0) {
		FREE(stuff_p->string);
	}
	FREE(stuff_p);
}
\f

/* at each bar line, see if there are any "til" clauses that are supposed
 * to end in this measure. If so, make sure they end within the time
 * signature for this measure. */

void
meas_stuff_chk()

{
	struct TIL_INFO *til_info_p;		/* to index thru list */
	struct TIL_INFO **del_place_p_p;	/* for deleting from list */
	struct TIL_INFO *one2free_p;		/* pointer to which element
						 * to free */

	debug(2, "meas_chk_stuff");

	/* update measure number to conpensate for any multirests */
	Measnum += Multi_adjust;
	Multi_adjust = 0;

	/* go through list of in-progress til clauses */
	for (til_info_p = Til_info_list_p, del_place_p_p = &Til_info_list_p;
				til_info_p != (struct TIL_INFO *) 0;  ) {

		if (til_info_p->measnum == Measnum) {

			/* at measure where this til clause ends */
			/* check if within time signature */
			if (til_info_p->count > Score.timenum + 1.0) {
				l_yyerror(til_info_p->inputfile,
					til_info_p->inputlineno,
					"beats in 'til' clause must be <= numerator of time signature + 1 of the measure in which the 'til' clause ends (i.e., <= %d)",
					Score.timenum);
			}

			/* this one has been taken care of: delete from list */
			*del_place_p_p = til_info_p->next;
			one2free_p = til_info_p;
		}
		else if (til_info_p->measnum < Measnum) {
			/* must have ended inside a multirest, so delete
 			 * from list */
			*del_place_p_p = til_info_p->next;
			one2free_p = til_info_p;
		}
		else {
			/* this one stays on the list for now, so move pointer
			 * to where to potentially delete to next element */
			del_place_p_p = &(til_info_p->next);
			one2free_p = (struct TIL_INFO *) 0;
		}

		/* have to move to next element
		 * before freeing the current one */
		til_info_p = til_info_p->next;

		if (one2free_p != (struct TIL_INFO *) 0) {
			FREE(one2free_p);
		}
	}

	/* update number of measures. */
	Measnum++;

	/* make sure pedal marks are in proper order */
	ped_order_chk();
}
\f

/* adjust number of measures to account for multirests. Called when there is
 * a multirest. Saved the number of measures in the multirest (minus 1 since
 * the barline at the end will count for one measure) */

void
multi_stuff(nmeas)

int nmeas;	/* number of measures in multirest */

{
	/* subtract 1 to account for the fact that at the bar line at the
	 * end of the multirest we will peg the measure counter */
	Multi_adjust = nmeas - 1;
}
\f

/* handle pedal going into endings. When we hit a first ending, save the
 * state of the pedal for all staffs. On subsequent endings in the set,
 * reset the pedal state to what it was at the beginning of the first ending.
 * At the endending, go back to normal operation. This is similar to
 * the saveped() function used at print time. */

void
ped_endings(endingloc)

int endingloc;		/* STARTITEM, INITEM, etc */

{
	register int s;		/* staff index */


	if (endingloc == STARTITEM) {
		if (Ped_snapshot[0] == YES) {

			/* starting 2nd ending: restore pedal state as it was
			 * at beginning of first ending */
			for (s = 1; s <= MAXSTAFFS; s++) {
				Pedal_state[s] = Ped_snapshot[s];
			}
		}

		else {
			/* starting a set of endings,
			 * need to save pedal state at this
			 * point so we can carry it into subsequent endings */
			for (s = 1; s <= Score.staffs; s++) {
				Ped_snapshot[s] = Pedal_state[s];
			}
			/* make sure any remaining staffs are set to pedal off,
			 * in case user increases the number of staffs
			 * during the endings... */
			for (   ; s <= MAXSTAFFS; s++) {
				Ped_snapshot[s] = NO;
			}

			/* mark that we now have a snapshot */
			Ped_snapshot[0] = YES;
		}
	}

	else if (endingloc == ENDITEM) {
		/* at end of endings, discard snapshot of pedal states */
		Ped_snapshot[0] = NO;
	}
}
\f

/* When all input has been processed, or when changing the number
 * of staffs, we better not have any 'til' clauses
 * still unfinished. If we do, print a warning message. */

void
chk4dangling_til_clauses(boundary_desc)

char *boundary_desc;		/* "the end of the song" or
				 * "a change in number of staffs" */

{
	struct TIL_INFO *til_info_p;


	debug(2, "chk4dangling_til_clauses");

	/* Go through the whole list of remaining til clauses,
	 * and print a warning message for each. */
	for (til_info_p = Til_info_list_p; til_info_p != (struct TIL_INFO *) 0;
					til_info_p = til_info_p->next) {

		/* If right on the boundary or spills over only a very tiny
		 * amount, don't bother to complain */
		if (til_info_p->measnum - Measnum == 0
						&& til_info_p->count < .001) {
			continue;
		}

		l_warning(til_info_p->inputfile, til_info_p->inputlineno,
				"'til' clause extends beyond %s by %dm + %.3f",
				boundary_desc, til_info_p->measnum - Measnum,
				til_info_p->count);
	}

	/* mop up. */
	free_tils(Til_info_list_p);
	Til_info_list_p = (struct TIL_INFO *) 0;
}
\f

/* recursively free a list of TIL_INFO structs */

static void
free_tils(til_p)

struct TIL_INFO *til_p;		/* free this list */

{
	if (til_p == (struct TIL_INFO *) 0) {
		return;
	}

	free_tils(til_p->next);
	FREE(til_p);
}
\f

/* user only has to specify when pedal marks end. We deduce from current
 * pedal state whether a pedal mark is begin or up/down. This gets called
 * whenever we have a list of pedal STUFFs. Later we enforce that pedal
 * marks are put in in ascending order only, so that if user enters more
 * than one pedal line for the same staff, that will be handled properly. */

static void
fix_pedal(staffno, stuff_p)

int staffno;			/* pedal is for this staff */
struct STUFF *stuff_p;		/* list of pedal mark info */

{
	/* walk through list of pedal marks */
	for (  ; stuff_p != (struct STUFF *) 0; stuff_p = stuff_p->next) {

		if (stuff_p->string == (char *) 0) {
			/* no star, so have to deduce state */

			if (Pedal_state[staffno] == NO) {
				/* pedal currently off, so begin pedal */
				Pedal_state[staffno] = YES;
				stuff_p->string = copy_string(Ped_begin_str + 2,
					(int) Ped_begin_str[0],
					(int) Ped_begin_str[1]);
			}
			else {
				/* pedal currently down, so pedal up/down */
				stuff_p->string = copy_string(Ped_up_down_str + 2,
					(int) Ped_up_down_str[0],
					(int) Ped_up_down_str[1]);
			}
		}

		else if (Pedal_state[staffno] == NO) {
			yyerror("can't end pedal -- none in progress");
		}

		else {
			/* user gave star, so end pedal */
			Pedal_state[staffno] = NO;
		}
	}
}
\f

/* reset pedal states for all staffs. This should be called at init time
 * and at any time when the number of staffs changes. This function also
 * initializes the Ped_begin_str and Ped_up_down_str. */

void
reset_ped_state()

{
	static int first_time = YES;	/* flag if function called before */
	register int s;			/* index through staffs */


	/* mark pedal off for all staffs */
	for (s = 1; s <= Score.staffs; s++) {
		Pedal_state[s] = NO;
	}
	Ped_snapshot[0] = NO;

	/* the first time this function is called, initialize the strings
	 * for pedal begin and pedal end. We just have one copy of these
	 * and then make as many copies from these as necessary */
	if (first_time == YES) {
		first_time = NO;
		Ped_begin_str = copy_string("\\(begped)", FONT_MUSIC,
							DFLT_SIZE);
		Ped_up_down_str = copy_string("\\(pedal)", FONT_MUSIC,
							DFLT_SIZE);
		fix_string(Ped_begin_str, FONT_MUSIC, DFLT_SIZE,
					Curr_filename, -1);
		fix_string(Ped_up_down_str, FONT_MUSIC, DFLT_SIZE,
					 Curr_filename, -1);
	}
}
\f

/* fill in rehearsal mark string. This doesn't go in a STUFF, but it's
 * sort of like stuff and there didn't seem to be any more appropriate file for
 * this function */


static int Reh_let = 0;		/* current value of rehearsal letter. 0 == "A",
				 * 25 == "Z", 26 == "AA", etc to 701 == "ZZ" */
static int Reh_num = 1;		/* current value of rehearsal number */


void
set_reh_string(bar_p, fontfamily, font, size, string)

struct BAR *bar_p;	/* which bar gets the rehearsal mark */
int fontfamily;		/* what font family to use, or FAMILY_DFLT
			 * if to use current default */
int font;		/* what font to use, or FONT_UNKNOWN if to use the
			 * current default font */
int size;		/* font size to use, or -1 if to use current default */
char *string;		/* string for rehearsal mark */

{
	char reh_str[12];	/* temporary buff for string version of
				 * rehearsal number or letter */
	static int reh_size = DFLT_SIZE;	/* size to use for reh marks */
	static int reh_family = FAMILY_DFLT;	/* font family to use */
	static int reh_font = FONT_TB;		/* font to use */


	/* if first time through, init the font family to the score family */
	if (reh_family == FAMILY_DFLT) {
		reh_family = Score.fontfamily;
	}

	/* if user specified a new size, save that */
	if (size != -1) {
		if (size > 100) {
			yyerror("reh mark size too large");
			return;
		}
		else {
			reh_size = size;
		}
	}

	/* if user specified new font or font family, save that */
	if (font != FONT_UNKNOWN) {
		reh_font = font;
	}
	if (fontfamily != FAMILY_DFLT) {
		reh_family = fontfamily;
	}

	switch(bar_p->reh_type) {

	case REH_NUM:
		/* get string version of current rehearsal number, and
		 * incrment it */
		bar_p->reh_string = copy_string(num2str(Reh_num++) + 2,
				reh_family + reh_font, reh_size);
		break;

	case REH_LET:
		/* Get string version of current rehearsal letter.
		 * Start with A-Z, then AA, AB, AC, ... BA, BB, ... up to ZZ.
		 */
		if (Reh_let < 26) {
			/* 1-letter long mark */
			(void) sprintf(reh_str, "%c", Reh_let + 'A');
		}
		else if (Reh_let < 27 * 26) {
			/* 2-letter long mark */
			(void) sprintf(reh_str, "%c%c",
				(Reh_let / 26) + 'A' - 1, (Reh_let % 26) + 'A');
		}
		else {
			ufatal("too many rehearsal letters!");
		}
		bar_p->reh_string = copy_string(reh_str,
				reh_family + reh_font, reh_size);
		/* increment for next time around */
		Reh_let++;
		break;

	case REH_MNUM:
		/* get string version of current measure number */
		bar_p->reh_string = copy_string(num2str(Meas_num) + 2,
				reh_family + reh_font, reh_size);
		break;

	case REH_STRING:
		/* user-specified string */
		bar_p->reh_string = fix_string(string,
				reh_family + reh_font, reh_size,
				Curr_filename, yylineno);
		break;

	case REH_NONE:
		break;

	default:
		pfatal("set_reh_string passed bad value");
		break;
	}
}
\f

/* Set rehearsal letter or number to user-specified value.
 * If the current bar has a rehearsal mark of the type being changed,
 * also replace its current mark with the changed one. This allows user
 * to say either
 *	reh num num=5
 * or
 *	num=5 reh num
 * and get the same results, which is consistent with how mnum= setting
 * had worked.
 */

void
init_reh(rehnumber, rehletter, mainbar_p)

int rehnumber;		/* New value for Reh_num or negative if setting Reh_let */
char *rehletter;	/* "A" to "ZZ" or null if setting number */
struct MAINLL *mainbar_p;	/* points to the current BAR */

{
	struct BAR *bar_p;
	char *oldstr;		/* previous reh_string */

	if (mainbar_p == 0 || mainbar_p->str != S_BAR) {
		pfatal("bad mainbar_p passed to init_reh");
	}
	bar_p = mainbar_p->u.bar_p;
	oldstr = bar_p->reh_string;

	if (rehnumber >= 0) {
		Reh_num = rehnumber;
		/* If this bar has a rehearsal number on this bar,
		 * replace it, and free the old one. */
		if (bar_p->reh_type == REH_NUM) {
			set_reh_string(bar_p, FAMILY_DFLT, FONT_UNKNOWN, -1,
								(char *) 0);
			FREE(oldstr);
		}
	}

	if (rehletter != 0) {
		/* Letter is stored internally as a number,
		 * which is then converted, so we have to convert in reverse.
		 * We only allow "A" through "ZZ" */
		if (isupper(rehletter[0]) && rehletter[1] == '\0') {
			Reh_let = rehletter[0] - 'A';
		}
		else if (isupper(rehletter[0]) && isupper(rehletter[1])
						&& rehletter[2] == '\0') {
			Reh_let = 26 + (rehletter[1] - 'A')
					+ (rehletter[0] - 'A') * 26;
		}
		else {
			yyerror("rehearsal letter setting must be \"A\" through \"ZZ\"");
			return;
		}
		/* If this bar has a rehearsal letter on this bar,
		 * replace it, and free the old one. */
		if (bar_p->reh_type == REH_LET) {
			set_reh_string(bar_p, FAMILY_DFLT, FONT_UNKNOWN, -1,
								(char *) 0);
			FREE(oldstr);
		}
	}
}
\f

/* go through all stuff lists and verify that pedal marks are given in
 * ascending order. If not, error. Some code in both parse and
 * placement phases requires that pedal marks be in order. */

static void
ped_order_chk()

{
	int staffno;
	struct STUFF *stuff_p;	/* walk through stuff list */
	float last_ped_count;	/* count where last pedal occurred */
	int last_backup;	/* gracebackup of last pedal */


	/* check every staff */
	for (staffno = 1; staffno <= Score.staffs; staffno++) {

		/* initialize for current staff */
		last_ped_count = -1.0;
		last_backup = 0;

		/* go through stuff list for current staff, looking for pedal */
		for (stuff_p = Staffmap_p[staffno]->u.staff_p->stuff_p;
					stuff_p != (struct STUFF *) 0;
					stuff_p = stuff_p->next) {
			if (stuff_p->stuff_type == ST_PEDAL) {

				/* found a pedal. Make sure it is later than
				 * the previous pedal */
				if (stuff_p->start.count < last_ped_count ||
						(stuff_p->start.count
						== last_ped_count
						&& stuff_p->gracebackup
						> last_backup) ) {
					l_yyerror(stuff_p->inputfile,
						stuff_p->inputlineno,
						"pedal must be specified in ascending order");
					/* no need to print error more than
					 * once if multiple errors */
					continue;
				}

				/* keep track of where this pedal is, for
				 * comparing with the next one */
				last_ped_count = stuff_p->start.count;
				last_backup = stuff_p->gracebackup;
			}
		}
	}
}
\f

/* Translate STUFF text modifier to a printable string. */

char *
stuff_modifier(modifier)

int modifier;

{
	switch (modifier) {

	case TM_CHORD:
		return("chord");
	case TM_ANALYSIS:
		return("analysis");
	case TM_FIGBASS:
		return("figbass");
	case TM_DYN:
		return("dyn");
	case TM_NONE:
		return("(no modifier)");
	default:
		return("(invalid modifier)");
	}
}