[mup] / mup / mup / parstssv.c

/* Copyright (c) 2003 by Arkkra Enterprises. */
/* All rights reserved. */

/* This file contains parse-time functions related to TIMEDSSVs.
 * These are used to specify mid-measure parameter changes,
 * like change of clef.
 */

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

/* Mid-measure SSV's eventually get attached to the BAR, but we need
 * to point to the list temporarily while the BAR doesn't exist yet. */
static struct TIMEDSSV *Timedssv_p;

/* When there is more than one TIMEDSSV at the same moment in time,
 * we use user input order, so we add items to the end of the list.
 * This keeps track of where to put the next one.
 */
static struct TIMEDSSV **Timed_tail_p_p = &Timedssv_p;

static struct TIMEDSSV *tssv_new P((int context));
\f

/* Allocate and initalize a TIMEDSSV for each staff/voice being defined,
 *  and return pointer to the first one.
 */

struct TIMEDSSV *
tssv_create(context)

int context;

{
	struct SVRANGELIST *svr_p;	/* list of staffs/voices being entered */
	struct RANGELIST *srange_p;	/* list of staffs being entered */
	struct RANGELIST *vrange_p;	/* list of voices being entered */
	struct TIMEDSSV *new_p;
	struct TIMEDSSV *first_p = 0;	/* first one created */
	int s;				/* staff number */
	int v;				/* voice number */

	/* Create as many new TIMEDSSVs as needed, based on the current list
	 * of staffs/voices being defined,
	 * link them onto the temporary list for the current measure.
	 */

	switch (context) {
	case C_SCORE:
		first_p = new_p = tssv_new(context);
		break;
	case C_STAFF:
	case C_VOICE:
		for (svr_p = Svrangelist_p; svr_p != 0; svr_p = svr_p->next) {
			for (srange_p = svr_p->stafflist_p; srange_p != 0;
						srange_p = srange_p->next) {
				for (s = srange_p->begin; s <= srange_p->end; s++) {
					if (context == C_STAFF) {
						new_p = tssv_new(context);
						if (first_p == 0) {
							first_p = new_p;
						}
						new_p->ssv.staffno = s;
					}
					else {
						for (vrange_p = svr_p->vnolist_p;
								vrange_p != 0;
								vrange_p = vrange_p->next) {
							for (v = vrange_p->begin;
								v <= vrange_p->end;
								v++) {
							   new_p = tssv_new(context);
							   if (first_p == 0) {
								first_p = new_p;
							   }
							   new_p->ssv.staffno = s;
							   new_p->ssv.voiceno = v;
							}
						}
					}
				}
			}
		}
		break;
	default:
		pfatal("invalid context %d when creating TIMEDSSV", context);
		/*NOTREACHED*/
		break;
	}
	return(first_p);
}
\f

/* Create a single TIMEDSSV and link it onto the list */

static struct TIMEDSSV *
tssv_new(context)

int context;

{
	struct TIMEDSSV *curr_tssv_p;

	CALLOC(TIMEDSSV, curr_tssv_p, 1);
	zapssv( & (curr_tssv_p->ssv) );
	curr_tssv_p->ssv.context = context;
	curr_tssv_p->grpsyl_p = 0;
	curr_tssv_p->time_off.n = -1;
	curr_tssv_p->time_off.d = 1;

	curr_tssv_p->next = 0;
	*Timed_tail_p_p = curr_tssv_p;
	Timed_tail_p_p = &(curr_tssv_p->next);

	return(curr_tssv_p);
}
\f

/* Save a parameter setting in the given TIMEDSSV. We only support a very
 * limited list of parameters that can be changed mid-measure,
 * so this checks for valid ones.
 */

void
tssv_update(timedssv_p, param, value)

struct TIMEDSSV *timedssv_p;
int param;
int value;

{
	/* Could be multiple staffs/voices, so do them all */
	for (  ; timedssv_p != 0; timedssv_p = timedssv_p->next) {
		switch (param) {
		case CLEF:
			timedssv_p->ssv.clef = value;
			break;
		case RELEASE:
			if (rangecheck(value, MINRELEASE, MAXRELEASE,
					"mid-measure release change") == YES) {
				timedssv_p->ssv.release = value;
			}
			break;
		case DEFOCT:
			if (rangecheck(value, MINOCTAVE, MAXOCTAVE,
					"mid-measure defoct change") == YES) {
				timedssv_p->ssv.defoct = value;
			}
			break;

		default:
			yyerror("only clef, defoct, and release parameters can be changed mid-measure");
			return;
		}
		if (timedssv_p->ssv.used[param] == YES) {
			warning("multiple changes of the same parameter; last used");
		}
		timedssv_p->ssv.used[param] = YES;
	}
}
\f

/* Associate grpsyl with TIMEDSSV. This should be called at the end of
 * parsing of a grpsyl, in case it has at least one timed ssv. */

void
tssv_setgrpsyl(gs_p)

struct GRPSYL *gs_p;

{
	struct TIMEDSSV *tssv_p;

	/* User could input multiple << >> things, and each gets their
	 * own TIMEDSSV, so we need to associate this grpsyl with
	 * all that don't yet have one.  */
	for (tssv_p = Timedssv_p; tssv_p != 0; tssv_p = tssv_p->next) {
		if (tssv_p->grpsyl_p == 0) {
			tssv_p->grpsyl_p = gs_p;

			/* Do some error checks */
			if (tssv_p->ssv.used[CLEF] == YES) {
				if (tssv_p->ssv.context == C_STAFF
						&& is_tab_staff(tssv_p->ssv.staffno)) {
					yyerror("can't change clef of tab staff");
				}
				if (tssv_p->ssv.context == C_VOICE) {
					yyerror("can't change clef in voice context");
				}
			}
		}
	}
}

\f

/* Do processing on one input line worth of TIMEDSSVs.
 */

void
tssv_line()
{
	struct TIMEDSSV *ts_p;
	struct GRPSYL *gs_p;

	/* First we have to find the time offsets of each TIMEDSSV.
	 * We can't necessarily calculate them at the time
	 * they were added to the list, since for tuplets
	 * we don't know fulltimes till we reach the end
	 * of the tuplet, and know how to adjust.
	 * So we just save the GRPSYL* at that point,
	 * and now we go through and find all the actual times.
	 */
	for (ts_p = Timedssv_p; ts_p != 0; ts_p = ts_p->next) {
		if (GE(ts_p->time_off, Zero)) {
			/* already set from some previous line */
			continue;
		}

		if (ts_p->grpsyl_p == 0) {
			/* This could happen if there was a user input
			 * error, because we could have set up the TIMEDSSV
			 * and then not been able to parse the GRPSYL that
			 * was intended to go with it.  Set time offset to
			 * a safe value, and skip the rest of the loop,
			 * so we don't try to dereference the null ptr. */
			ts_p->time_off = Zero;
			continue;
		}

		/* Count up the time before the group where the timed
		 * SSV was specified. */
		for (ts_p->time_off = Zero, gs_p = ts_p->grpsyl_p->prev;
						gs_p != 0; gs_p = gs_p->prev) {
			/* Alt groups have not yet had their time adjusted,
			 * so we have to compensate for that. */
			if (gs_p->slash_alt < 0 || (gs_p->prev != 0
					&& gs_p->prev->slash_alt < 0) ) {
				ts_p->time_off = radd(ts_p->time_off,
						rdiv(gs_p->fulltime, Two));
			}
			else if (gs_p->grpvalue != GV_ZERO) {
				ts_p->time_off = radd(ts_p->time_off,
							gs_p->fulltime);
			}
		}
	}
}
\f

/* Sort the current TIMEDSSV list by time and return pointer to the head
 * of the sorted list. The sorting is done by time. When there is a tie
 * things are put in user input order. Also re-inits for the next measure.
 */

struct TIMEDSSV *
tssv_sort()

{
	struct TIMEDSSV *ret;	/* return value is pointer to sorted list */
	short moved;		/* YES if something was moved during sort */

	/* Most of the time, the list will be empty. */
	if (Timedssv_p == 0) {
		return(0);
	}

	/* Sort in time order.
	 * The list is almost certain to be very short,
	 * so sort needn't be very efficient. So we check pairs
	 * and swap ones that are backwards. */
	do {
		struct TIMEDSSV **ts_p_p;
		struct TIMEDSSV *tmp_ts_p;

		moved = NO;
		for (ts_p_p = &Timedssv_p; (*ts_p_p)->next != 0;
						ts_p_p = &((*ts_p_p)->next) ) {
			if ( GT( (*ts_p_p)->time_off, (*ts_p_p)->next->time_off ) ) {
				/* Wrong order. Swap them */
				tmp_ts_p = (*ts_p_p)->next;
				(*ts_p_p)->next = (*ts_p_p)->next->next;
				tmp_ts_p->next = *ts_p_p;
				*ts_p_p = tmp_ts_p;
				moved = YES;
				break;
			}
		}
	} while (moved == YES);
	ret = Timedssv_p;

	/* re-init for next measure */
	Timedssv_p = 0;
	Timed_tail_p_p = &(Timedssv_p);
	return(ret);
}
Commit	Line	Data
69695f33 MW	1	/* Copyright (c) 2003 by Arkkra Enterprises. */
	2	/* All rights reserved. */
	3
	4	/* This file contains parse-time functions related to TIMEDSSVs.
	5	* These are used to specify mid-measure parameter changes,
	6	* like change of clef.
	7	*/
	8
	9	#include "defines.h"
	10	#include "structs.h"
	11	#include "globals.h"
	12
	13	/* Mid-measure SSV's eventually get attached to the BAR, but we need
	14	* to point to the list temporarily while the BAR doesn't exist yet. */
	15	static struct TIMEDSSV *Timedssv_p;
	16
	17	/* When there is more than one TIMEDSSV at the same moment in time,
	18	* we use user input order, so we add items to the end of the list.
	19	* This keeps track of where to put the next one.
	20	*/
	21	static struct TIMEDSSV **Timed_tail_p_p = &Timedssv_p;
	22
	23	static struct TIMEDSSV *tssv_new P((int context));
	24	\f
	25
	26	/* Allocate and initalize a TIMEDSSV for each staff/voice being defined,
	27	* and return pointer to the first one.
	28	*/
	29
	30	struct TIMEDSSV *
	31	tssv_create(context)
	32
	33	int context;
	34
	35	{
	36	struct SVRANGELIST svr_p; / list of staffs/voices being entered */
	37	struct RANGELIST srange_p; / list of staffs being entered */
	38	struct RANGELIST vrange_p; / list of voices being entered */
	39	struct TIMEDSSV *new_p;
	40	struct TIMEDSSV first_p = 0; / first one created */
	41	int s; /* staff number */
	42	int v; /* voice number */
	43
	44	/* Create as many new TIMEDSSVs as needed, based on the current list
	45	* of staffs/voices being defined,
	46	* link them onto the temporary list for the current measure.
	47	*/
	48
	49	switch (context) {
	50	case C_SCORE:
	51	first_p = new_p = tssv_new(context);
	52	break;
	53	case C_STAFF:
	54	case C_VOICE:
	55	for (svr_p = Svrangelist_p; svr_p != 0; svr_p = svr_p->next) {
	56	for (srange_p = svr_p->stafflist_p; srange_p != 0;
	57	srange_p = srange_p->next) {
	58	for (s = srange_p->begin; s <= srange_p->end; s++) {
	59	if (context == C_STAFF) {
	60	new_p = tssv_new(context);
	61	if (first_p == 0) {
	62	first_p = new_p;
	63	}
	64	new_p->ssv.staffno = s;
65	}
66	else {
67	for (vrange_p = svr_p->vnolist_p;
68	vrange_p != 0;
69	vrange_p = vrange_p->next) {
70	for (v = vrange_p->begin;
71	v <= vrange_p->end;
72	v++) {
73	new_p = tssv_new(context);
74	if (first_p == 0) {
75	first_p = new_p;
76	}
77	new_p->ssv.staffno = s;
78	new_p->ssv.voiceno = v;
79	}
80	}
81	}
82	}
83	}
84	}
85	break;
86	default:
87	pfatal("invalid context %d when creating TIMEDSSV", context);
88	/NOTREACHED/
89	break;
90	}
91	return(first_p);
92	}
93	\f
94
95	/* Create a single TIMEDSSV and link it onto the list */
96
97	static struct TIMEDSSV *
98	tssv_new(context)
99
100	int context;
101
102	{
103	struct TIMEDSSV *curr_tssv_p;
104
105	CALLOC(TIMEDSSV, curr_tssv_p, 1);
106	zapssv( & (curr_tssv_p->ssv) );
107	curr_tssv_p->ssv.context = context;
108	curr_tssv_p->grpsyl_p = 0;
109	curr_tssv_p->time_off.n = -1;
110	curr_tssv_p->time_off.d = 1;
111
112	curr_tssv_p->next = 0;
113	*Timed_tail_p_p = curr_tssv_p;
114	Timed_tail_p_p = &(curr_tssv_p->next);
115
116	return(curr_tssv_p);
117	}
118	\f
119
120	/* Save a parameter setting in the given TIMEDSSV. We only support a very
121	* limited list of parameters that can be changed mid-measure,
122	* so this checks for valid ones.
123	*/
124
125	void
126	tssv_update(timedssv_p, param, value)
127
128	struct TIMEDSSV *timedssv_p;
129	int param;
130	int value;
131
132	{
133	/* Could be multiple staffs/voices, so do them all */
134	for ( ; timedssv_p != 0; timedssv_p = timedssv_p->next) {
135	switch (param) {
136	case CLEF:
137	timedssv_p->ssv.clef = value;
138	break;
139	case RELEASE:
140	if (rangecheck(value, MINRELEASE, MAXRELEASE,
141	"mid-measure release change") == YES) {
142	timedssv_p->ssv.release = value;
143	}
144	break;
145	case DEFOCT:
146	if (rangecheck(value, MINOCTAVE, MAXOCTAVE,
147	"mid-measure defoct change") == YES) {
148	timedssv_p->ssv.defoct = value;
149	}
150	break;
151
152	default:
153	yyerror("only clef, defoct, and release parameters can be changed mid-measure");
154	return;
155	}
156	if (timedssv_p->ssv.used[param] == YES) {
157	warning("multiple changes of the same parameter; last used");
158	}
159	timedssv_p->ssv.used[param] = YES;
160	}
161	}
162	\f
163
164	/* Associate grpsyl with TIMEDSSV. This should be called at the end of
165	* parsing of a grpsyl, in case it has at least one timed ssv. */
166
167	void
168	tssv_setgrpsyl(gs_p)
169
170	struct GRPSYL *gs_p;
171
172	{
173	struct TIMEDSSV *tssv_p;
174
175	/* User could input multiple << >> things, and each gets their
176	* own TIMEDSSV, so we need to associate this grpsyl with
177	* all that don't yet have one. */
178	for (tssv_p = Timedssv_p; tssv_p != 0; tssv_p = tssv_p->next) {
179	if (tssv_p->grpsyl_p == 0) {
180	tssv_p->grpsyl_p = gs_p;
181
182	/* Do some error checks */
183	if (tssv_p->ssv.used[CLEF] == YES) {
184	if (tssv_p->ssv.context == C_STAFF
185	&& is_tab_staff(tssv_p->ssv.staffno)) {
186	yyerror("can't change clef of tab staff");
187	}
188	if (tssv_p->ssv.context == C_VOICE) {
189	yyerror("can't change clef in voice context");
190	}
191	}
192	}
193	}
194	}
195
196	\f
197
198	/* Do processing on one input line worth of TIMEDSSVs.
199	*/
200
201	void
202	tssv_line()
203	{
204	struct TIMEDSSV *ts_p;
205	struct GRPSYL *gs_p;
206
207	/* First we have to find the time offsets of each TIMEDSSV.
208	* We can't necessarily calculate them at the time
209	* they were added to the list, since for tuplets
210	* we don't know fulltimes till we reach the end
211	* of the tuplet, and know how to adjust.
212	* So we just save the GRPSYL* at that point,
213	* and now we go through and find all the actual times.
214	*/
215	for (ts_p = Timedssv_p; ts_p != 0; ts_p = ts_p->next) {
216	if (GE(ts_p->time_off, Zero)) {
217	/* already set from some previous line */
218	continue;
219	}
220
221	if (ts_p->grpsyl_p == 0) {
222	/* This could happen if there was a user input
223	* error, because we could have set up the TIMEDSSV
224	* and then not been able to parse the GRPSYL that
225	* was intended to go with it. Set time offset to
226	* a safe value, and skip the rest of the loop,
227	* so we don't try to dereference the null ptr. */
228	ts_p->time_off = Zero;
229	continue;
230	}
231
232	/* Count up the time before the group where the timed
233	* SSV was specified. */
234	for (ts_p->time_off = Zero, gs_p = ts_p->grpsyl_p->prev;
235	gs_p != 0; gs_p = gs_p->prev) {
236	/* Alt groups have not yet had their time adjusted,
237	* so we have to compensate for that. */
238	if (gs_p->slash_alt < 0 \|\| (gs_p->prev != 0
239	&& gs_p->prev->slash_alt < 0) ) {
240	ts_p->time_off = radd(ts_p->time_off,
241	rdiv(gs_p->fulltime, Two));
242	}
243	else if (gs_p->grpvalue != GV_ZERO) {
244	ts_p->time_off = radd(ts_p->time_off,
245	gs_p->fulltime);
246	}
247	}
248	}
249	}
250	\f
251
252	/* Sort the current TIMEDSSV list by time and return pointer to the head
253	* of the sorted list. The sorting is done by time. When there is a tie
254	* things are put in user input order. Also re-inits for the next measure.
255	*/
256
257	struct TIMEDSSV *
258	tssv_sort()
259
260	{
261	struct TIMEDSSV ret; / return value is pointer to sorted list */
262	short moved; /* YES if something was moved during sort */
263
264	/* Most of the time, the list will be empty. */
265	if (Timedssv_p == 0) {
266	return(0);
267	}
268
269	/* Sort in time order.
270	* The list is almost certain to be very short,
271	* so sort needn't be very efficient. So we check pairs
272	* and swap ones that are backwards. */
273	do {
274	struct TIMEDSSV **ts_p_p;
275	struct TIMEDSSV *tmp_ts_p;
276
277	moved = NO;
278	for (ts_p_p = &Timedssv_p; (*ts_p_p)->next != 0;
279	ts_p_p = &((*ts_p_p)->next) ) {
280	if ( GT( (ts_p_p)->time_off, (ts_p_p)->next->time_off ) ) {
281	/* Wrong order. Swap them */
282	tmp_ts_p = (*ts_p_p)->next;
283	(ts_p_p)->next = (ts_p_p)->next->next;
284	tmp_ts_p->next = *ts_p_p;
285	*ts_p_p = tmp_ts_p;
286	moved = YES;
287	break;
288	}
289	}
290	} while (moved == YES);
291	ret = Timedssv_p;
292
293	/* re-init for next measure */
294	Timedssv_p = 0;
295	Timed_tail_p_p = &(Timedssv_p);
296	return(ret);
297	}