--- /dev/null
+/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2005 by Arkkra Enterprises */
+/* All rights reserved */
+/*
+ * Name: stuff.c
+ *
+ * Description: This file contains functions for handling "stuff".
+ */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+/* for STUFF, apply appropriate staffscale, based on "all" */
+#define STUFFSTEP(stuff_p) ((stuff_p)->all == YES ? \
+ Score.staffscale * STEPSIZE : stepsize);
+
+static void normalizestuff P((void));
+static void movestuff P((struct STAFF *staff1_p, struct STAFF *staff2_p,
+ struct STUFF *stuff_p));
+static void setphrases P((void));
+static void phrasestuff P((struct MAINLL *msbeg_p, struct STUFF *stuff_p));
+static void set1phrase P((struct MAINLL *msbeg_p, struct STUFF *stuff_p,
+ int v));
+static void rmstuff P((struct STAFF *staff_p, struct STUFF *stuff_p));
+static void breakstuff P((void));
+static struct STUFF *prevstuff P((struct MAINLL *mainll_p,
+ struct STUFF *stuff_p));
+static void breakone P((struct MAINLL *m2_p, struct STUFF *stuff_p,
+ int timenum, char *origstr_p, int depth));
+static void contpedal P((void));
+static void setstuff P((void));
+static double count2coord P((double count, struct BAR *bar_p,
+ struct CHHEAD *chhead_p, int timeden));
+static int geteast P((struct STUFF *stuff_p, struct MAINLL *m2_p,
+ short *timeden2_p, struct CHHEAD **chhead2_p_p,
+ struct BAR **bar2_p_p));
+static int setmrferm P((struct STAFF *staff_p, struct STUFF *stuff_p));
+static int trygrid P((struct MAINLL *mainll_p, struct STUFF *stuff_p));
+static void tieslurstuff P((void));
+static void mktieslurstuff P((struct MAINLL *mllstaff_p, struct GRPSYL *gs_p,
+ int n, int s));
+static void mkextrastuff P((struct MAINLL *mll_p, struct STUFF *origstuff_p,
+ struct GRPSYL *gs_p, int n, int s, int stufftype));
+\f
+/*
+ * Name: stuff()
+ *
+ * Abstract: Perform all necessary horizontal operations on STUFF.
+ *
+ * Returns: void
+ *
+ * Description: This function calls subroutines to do all necessary horizontal
+ * operations on STUFF.
+ */
+
+void
+stuff()
+{
+ debug(16, "stuff");
+ normalizestuff();
+ setphrases();
+ breakstuff();
+ contpedal();
+ setstuff();
+ tieslurstuff();
+}
+\f
+/*
+ * Name: normalizestuff()
+ *
+ * Abstract: Normalize STUFF starting at count N + 1 before a FEED.
+ *
+ * Returns: void
+ *
+ * Description: This function looks for all STUFF structures that start at
+ * count N + 1 (where N is the numerator of the time signature)
+ * in measures preceding a score feed. These things really
+ * should be drawn at the start of the next score, so this
+ * function moves them to be at count 0 of the next measure.
+ * However, if the staff involved is invisible on the next score,
+ * it doesn't move the STUFF. Also, fermatas and the pedal marks
+ * PEDAL and ENDPED are not moved.
+ * Only start.count is used; the policy is to apply start.steps
+ * only after everything else is done.
+ */
+
+static void
+normalizestuff()
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct MAINLL *m2_p, *m3_p; /* secondary & tertiary MLL pointers */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct STUFF *next_p; /* point at the next STUFF structure */
+
+
+ debug(16, "normalizestuff");
+ initstructs();
+
+ /*
+ * Loop through the main linked list, looking for BARs that immediately
+ * precede a FEED. When found, adjust the start count of STUFFs in the
+ * preceding measure if necessary.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* keep SSVs up to date; we need to know time sig */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+
+ case S_BAR:
+ /* break out to handle this BAR */
+ break;
+
+ default:
+ /* nothing to do, skip to next loop */
+ continue;
+ }
+
+ /*
+ * Find out if this is a bar that immediately precedes a FEED.
+ * If not, there is no need to adjust any stuff, so continue.
+ */
+ for (m2_p = mainll_p; m2_p != 0 && m2_p->str != S_FEED &&
+ m2_p->str != S_CHHEAD; m2_p = m2_p->next)
+ ;
+ if (m2_p == 0 || m2_p->str == S_CHHEAD)
+ continue;
+
+ /*
+ * This bar immediately precedes a FEED. Make sure the number
+ * of staffs doesn't change across this FEED. (And if what
+ * follows are blocks, continue looking until we find a FEED
+ * that is not a block.) If it does, don't move any STUFF.
+ */
+ for (m2_p = mainll_p; m2_p->next != 0; m2_p = m2_p->next) {
+ /* break out if a FEED that is not followed by block */
+ if (m2_p->str == S_FEED &&
+ m2_p->next->str != S_BLOCKHEAD)
+ break;
+ /* break out if SSV changes number of staffs */
+ if (m2_p->str == S_SSV &&
+ m2_p->u.ssv_p->used[NUMSTAFF] == YES)
+ break;
+ }
+ /* if at end of list or staffs changed, don't move stuff */
+ if (m2_p->next == 0 || m2_p->str == S_SSV)
+ continue;
+
+ /*
+ * Search back to the CHHEAD of the preceding measure.
+ */
+ for (m2_p = mainll_p; m2_p->str != S_CHHEAD; m2_p = m2_p->prev)
+ ;
+
+ /*
+ * Loop through all the staffs in this preceding measure,
+ * adjusting STUFF when need be.
+ */
+ for (m2_p = m2_p->next; m2_p->str == S_STAFF;
+ m2_p = m2_p->next) {
+
+ if (m2_p->u.staff_p->visible == NO)
+ continue;
+
+ /*
+ * Find the matching STAFF in the next measure. If we
+ * can't find it (like end of MLL) or it's not visible,
+ * forget this staff.
+ */
+ for (m3_p = mainll_p->next; m3_p != 0 &&
+ m3_p->str != S_BAR; m3_p = m3_p->next) {
+ if (m3_p->str == S_STAFF &&
+ m3_p->u.staff_p->staffno ==
+ m2_p->u.staff_p->staffno)
+ break;
+ }
+ if (m3_p == 0 || m3_p->str != S_STAFF ||
+ m3_p->u.staff_p->visible == NO)
+ continue;
+
+ /*
+ * Loop through all the stuff on this staff in the
+ * preceding measure, normalizing it. That is, if it
+ * starts at count N + 1 (where N is the numerator of
+ * the time signature), change it to start at count 0
+ * of the next bar line. However, don't move fermatas
+ * or pedal "bounce" or "ending" marks.
+ */
+ for (stuff_p = m2_p->u.staff_p->stuff_p;
+ stuff_p != 0; stuff_p = next_p) {
+ /*
+ * Remember next one in case we have to move
+ * this one to the next measure's linked list.
+ */
+ next_p = stuff_p->next;
+
+ if (stuff_p->start.count == Score.timenum + 1 &&
+ string_is_sym(stuff_p->string, C_PEDAL, FONT_MUSIC) == NO &&
+ string_is_sym(stuff_p->string, C_ENDPED, FONT_MUSIC) == NO &&
+ string_is_sym(stuff_p->string, C_FERM, FONT_MUSIC) == NO &&
+ string_is_sym(stuff_p->string, C_UFERM, FONT_MUSIC) == NO) {
+ /*
+ * Move this stuff from preceding to
+ * following measure's linked list.
+ */
+ movestuff(m2_p->u.staff_p,
+ m3_p->u.staff_p, stuff_p);
+ /*
+ * Set start count to 0. If there is a
+ * "til" clause, bars would have to be
+ * greater than 0, since count can't
+ * refer to a count in this measure
+ * (can't be greater than N + 1). So
+ * we only need to check bars to see if
+ * there's a "til" clause. If there
+ * is, decrement it.
+ */
+ stuff_p->start.count = 0;
+ if (stuff_p->end.bars > 0)
+ stuff_p->end.bars--;
+ }
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: movestuff()
+ *
+ * Abstract: Move a STUFF from one linked list to another.
+ *
+ * Returns: void
+ *
+ * Description: This function, given two staff pointers, finds the given STUFF
+ * in the first one's linked list of STUFF. It removes it from
+ * there and adds it to the start of the second staff's list.
+ */
+
+static void
+movestuff(staff1_p, staff2_p, stuff_p)
+
+struct STAFF *staff1_p; /* first STAFF */
+struct STAFF *staff2_p; /* second STAFF */
+struct STUFF *stuff_p; /* the STUFF to be moved */
+
+{
+ struct STUFF *s_p; /* loop pointer */
+
+
+ debug(32, "movestuff file=%s line=%d", stuff_p->inputfile,
+ stuff_p->inputlineno);
+ if (staff1_p->stuff_p == stuff_p) {
+ /*
+ * This STUFF is the first one in the first STAFF's linked
+ * list. Change the headcell to point at the next one (which
+ * removes it from this list). This "next one" could be null.
+ */
+ staff1_p->stuff_p = stuff_p->next;
+ } else {
+ /*
+ * Find which STUFF in the first STAFF's list points at the one
+ * we want to move. Make it point at the following one.
+ */
+ for (s_p = staff1_p->stuff_p; s_p->next != stuff_p;
+ s_p = s_p->next)
+ ;
+ s_p->next = stuff_p->next;
+ }
+
+ /*
+ * Make the STUFF we are moving point at what used to be the first
+ * one in the second STAFF's linked list. Make the second STAFF's
+ * headcell point at the STUFF we are moving.
+ */
+ stuff_p->next = staff2_p->stuff_p;
+ staff2_p->stuff_p = stuff_p;
+}
+\f
+/*
+ * Name: setphrases()
+ *
+ * Abstract: Find endpoints and direction of all phrase marks.
+ *
+ * Returns: void
+ *
+ * Description: This function loops through the main linked list and all STUFF,
+ * looking for phrase marks. For each phrase mark, it calls
+ * phrasestuff() to find out the horizontal positioning of the
+ * endpoints and whether the phrase mark should be above or below.
+ */
+
+static void
+setphrases()
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct STUFF **phrasearray; /* malloc array of pointers to stuff */
+ int numphrases; /* number of phrases in linked list */
+ int n; /* loop through phrasearray */
+
+
+ debug(16, "setphrases");
+ initstructs();
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* keep SSVs up to date; we need to know time sig */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+
+ case S_STAFF:
+ /* break out to handle this STAFF */
+ break;
+
+ default:
+ /* nothing to do, skip to next loop */
+ continue;
+ }
+
+ /*
+ * For each phrase in this staff's stuff list, we need to
+ * determine whether it should print 0, 1, or 2 phrase marks,
+ * and the direction and endpoints of each. We can't simply
+ * loop through the linked list, because the list gets altered
+ * by the subroutines we call, which can add and delete phrases
+ * from the list. So we copy the pointers to an array first.
+ */
+ /* count how many phrases are in this staff's stuff list */
+ numphrases = 0;
+ for (stuff_p = mainll_p->u.staff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->stuff_type == ST_PHRASE)
+ numphrases++;
+ }
+
+ /* if no phrases, nothing to do */
+ if (numphrases == 0)
+ continue;
+
+ /* allocate an array to hold pointer(s) to the phrase(s) */
+ MALLOCA(struct STUFF *, phrasearray, numphrases);
+
+ /* fill the array with pointers to each phrase */
+ n = 0;
+ for (stuff_p = mainll_p->u.staff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->stuff_type == ST_PHRASE)
+ phrasearray[n++] = stuff_p;
+ }
+
+ /* find endpoints and direction of phrase(s) from each stuff */
+ for (n = 0; n < numphrases; n++) {
+ phrasestuff(mainll_p, phrasearray[n]);
+ }
+
+ FREE(phrasearray);
+ }
+}
+\f
+/*
+ * Name: phrasestuff()
+ *
+ * Abstract: Find endpoints and direction of phrase(s) from one STUFF.
+ *
+ * Returns: void
+ *
+ * Description: This function decides whether the given phrase STUFF should
+ * try to generate one or two phrase marks above, below, or both.
+ * If it's both, it inserts a new STUFF in the list for it. Then
+ * it calls set1phrase() for each desired phrase to find endpoints
+ * and set the place if it's unknown.
+ */
+
+static void
+phrasestuff(msbeg_p, stuff_p)
+
+struct MAINLL *msbeg_p; /* point at main linked list where phrase starts */
+struct STUFF *stuff_p; /* point at STUFF structure for start of phrase */
+
+{
+ struct STUFF *stuff2_p; /* if we need to create a 2nd phrase */
+
+
+ debug(32, "phrasestuff file=%s line=%d", stuff_p->inputfile,
+ stuff_p->inputlineno);
+ switch (svpath(msbeg_p->u.staff_p->staffno, VSCHEME)->vscheme) {
+ case V_1: /* one voice */
+ /* do phrase mark for first (only) voice if possible */
+ set1phrase(msbeg_p, stuff_p, 0);
+ break;
+
+ case V_2FREESTEM: /* two voices that are free if one is space */
+ case V_3FREESTEM: /* same as above; STUFF ignores voice 3 */
+ if (chkallspace(msbeg_p, stuff_p, 0) == YES) {
+ /* first voice all spaces, apply phrase to second */
+ set1phrase(msbeg_p, stuff_p, 1);
+ break;
+ } else if (chkallspace(msbeg_p, stuff_p, 1) == YES) {
+ /* second voice all spaces, apply phrase to first */
+ set1phrase(msbeg_p, stuff_p, 0);
+ break;
+ }
+ /* FALL THROUGH to handle like V_2OPSTEM */
+
+ case V_2OPSTEM: /* two voices that always oppose */
+ case V_3OPSTEM: /* same as above; STUFF ignores voice 3 */
+ switch (stuff_p->place) {
+
+ case PL_ABOVE:
+ /* phrase requested only for top voice */
+ set1phrase(msbeg_p, stuff_p, 0);
+ break;
+
+ case PL_BELOW:
+ /* phrase requested only for bottom voice */
+ set1phrase(msbeg_p, stuff_p, 1);
+ break;
+
+ default:
+ /*
+ * We're going to have two phrase marks, one above the
+ * first voice and one below the second voice. Let the
+ * current STUFF be for the top one, and create a new
+ * STUFF for the bottom one.
+ */
+ stuff_p->place = PL_ABOVE;
+ stuff2_p = newSTUFF((char *)0,
+ stuff_p->dist,
+ stuff_p->dist_usage,
+ stuff_p->start.count,
+ stuff_p->start.steps,
+ stuff_p->gracebackup,
+ stuff_p->end.bars, stuff_p->end.count,
+ ST_PHRASE, NO, PL_BELOW,
+ stuff_p->inputfile,
+ stuff_p->inputlineno);
+ stuff2_p->next = stuff_p->next;
+ stuff_p->next = stuff2_p;
+
+ set1phrase(msbeg_p, stuff_p, 0);
+ set1phrase(msbeg_p, stuff2_p, 1);
+ break;
+ }
+ break;
+ }
+}
+\f
+/*
+ * Name: set1phrase()
+ *
+ * Abstract: Find endpoints and direction of one phrase.
+ *
+ * Returns: void
+ *
+ * Description: This function, given a STUFF for a single phrase mark and the
+ * voice it should apply to, finds the endpoint GRPSYLs for the
+ * phrase. If it can't find valid GRPSYLs, it removes the phrase
+ * and prints a warning. Otherwise, it also decides whether the
+ * phrase should be above or below, if that is not already known.
+ */
+
+static void
+set1phrase(msbeg_p, stuff_p, v)
+
+struct MAINLL *msbeg_p; /* point at MLL (staff) where phrase begins */
+struct STUFF *stuff_p; /* point at STUFF structure for start of phrase */
+int v; /* which voice to attach the phrase to */
+
+{
+ struct MAINLL *msend_p; /* MLL (staff) where phrase ends */
+ struct MAINLL *mll_p; /* for looping through MLL */
+ struct GRPSYL *beggrp_p;/* (eventually is) beginning of phrase */
+ struct GRPSYL *endgrp_p;/* (eventually is) end of phrase */
+ struct GRPSYL *gs_p; /* for looping through GRPSYL lists */
+ int staffno; /* the staff this phrase is on */
+ int timeden; /* denominator of time sig at end of phrase */
+ int up, down; /* count stem directions */
+ int n; /* loop variable */
+
+
+ debug(32, "set1phrase file=%s line=%d v=%d", stuff_p->inputfile,
+ stuff_p->inputlineno, v);
+ stuff_p->vno = v + 1; /* translate voice numbers 0, 1 to 1, 2 */
+ staffno = msbeg_p->u.staff_p->staffno;
+
+ /*
+ * Find what measure this phrase mark ends in. Along the way, keep
+ * track of the time signature denominator, in case it changes. If
+ * getendstuff() returns 0, it means the phrase runs into a multirest,
+ * which is not allowed. If the phrase is supposed to be attached to
+ * the bottom voice, but it ends in a measure where the vscheme is 1,
+ * we must also throw it away. (This condition is signaled by the
+ * groups_p[v] being a null pointer.)
+ */
+ msend_p = getendstuff(msbeg_p, stuff_p, &timeden);
+
+ if (msend_p == 0) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (runs into multirest)");
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+ if (msend_p->u.staff_p->groups_p[v] == 0) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (covers no notes in last measure)");
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+
+ /*
+ * Find the GRPSYLs that are closest, timewise, to the requested
+ * beginning and ending times of the phrase mark.
+ */
+ beggrp_p = closestgroup(stuff_p->start.count,
+ msbeg_p->u.staff_p->groups_p[v], Score.timeden);
+ endgrp_p = closestgroup(stuff_p->end.count,
+ msend_p->u.staff_p->groups_p[v], timeden);
+
+ /*
+ * It's possible that *beggrp_p is a rest or a space, but a phrase must
+ * start on a note group. So search forward, if necessary, to the first
+ * note group after this point. If there is none in this measure, this
+ * is an illegal phrase mark. Also, if the phrase begins and ends in
+ * the same measure, check that we don't go past the end in doing this
+ * search. A phrase is not allowed to begin and end at the same group.
+ * But the two groups can be the same if gracebackup is being used,
+ * because in that case the beginning group is really a grace group
+ * before the ending group. In any case, apply gracebackup if
+ * requested.
+ */
+ while (beggrp_p != 0 && beggrp_p->grpcont != GC_NOTES) {
+ if (beggrp_p == endgrp_p)
+ break;
+ beggrp_p = nextnongrace(beggrp_p);
+ }
+ if (beggrp_p == 0) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (covers no notes in first measure)");
+
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+ if (beggrp_p == endgrp_p && stuff_p->gracebackup == 0) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (need multiple notes)");
+
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+ /* found a valid starting point; back up grace notes if requested */
+ for (n = 0; n < stuff_p->gracebackup; n++) {
+ beggrp_p = beggrp_p->prev;
+ if (beggrp_p == 0 || beggrp_p->grpvalue != GV_ZERO) {
+ l_ufatal(stuff_p->inputfile, stuff_p->inputlineno,
+ "not enough grace groups to back up to for phrase");
+ }
+ }
+
+ /*
+ * Do the equivalent thing with the end of the phrase mark, except that
+ * we don't have to deal with gracebackup.
+ */
+ while (endgrp_p != 0 && endgrp_p->grpcont != GC_NOTES &&
+ beggrp_p != endgrp_p) {
+ endgrp_p = prevnongrace(endgrp_p);
+ }
+ if (beggrp_p == endgrp_p) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (need multiple notes)");
+
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+ if (endgrp_p == 0) {
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "removing invalid phrase (covers no notes in last measure)");
+
+ rmstuff(msbeg_p->u.staff_p, stuff_p);
+ return;
+ }
+
+ /*
+ * We have now determined the correct beginning and ending GRPSYLs for
+ * the phrase. Store them for later use.
+ */
+ stuff_p->beggrp_p = beggrp_p;
+ stuff_p->endgrp_p = endgrp_p;
+
+ /*
+ * If we don't know yet whether the phrase should be drawn above or
+ * below the staff, decide that now. We will put it on the side that
+ * has more note heads than stems. So loop through all GRPSYLs within
+ * this phrase, counting. Ignore grace groups.
+ */
+ if (stuff_p->place == PL_UNKNOWN) {
+ up = down = 0;
+ mll_p = msbeg_p;
+ gs_p = beggrp_p;
+ if (gs_p->grpvalue == GV_ZERO)
+ gs_p = nextnongrace(gs_p);
+ while (gs_p != endgrp_p) {
+ if (gs_p->grpcont == GC_NOTES) {
+ if (gs_p->stemdir == UP)
+ up++;
+ else
+ down++;
+ }
+
+ gs_p = nextnongrace(gs_p);
+
+ /* if we hit the end of a measure, find start of next */
+ if (gs_p == 0) {
+ for (mll_p = mll_p->next;
+ mll_p->str != S_STAFF ||
+ mll_p->u.staff_p->staffno != staffno;
+ mll_p = mll_p->next)
+ ;
+ gs_p = mll_p->u.staff_p->groups_p[v];
+ }
+ }
+ /* count final group in phrase (must be GC_NOTES) */
+ if (gs_p->stemdir == UP)
+ up++;
+ else
+ down++;
+
+ /*
+ * Put phrase opposite the majority of the stems. If it's a
+ * tie, base it on the first group.
+ */
+ if (up > down)
+ stuff_p->place = PL_BELOW;
+ else if (up < down)
+ stuff_p->place = PL_ABOVE;
+ else if (beggrp_p->stemdir == UP)
+ stuff_p->place = PL_BELOW;
+ else
+ stuff_p->place = PL_ABOVE;
+ }
+}
+\f
+/*
+ * Name: rmstuff()
+ *
+ * Abstract: Remove a STUFF from a linked list, and free it.
+ *
+ * Returns: void
+ *
+ * Description: This function removes the given STUFF from the linked list
+ * hanging off the given staff, and frees it.
+ */
+
+static void
+rmstuff(staff_p, stuff_p)
+
+struct STAFF *staff_p; /* the staff that the stuff hangs off of */
+struct STUFF *stuff_p; /* the stuff to be removed */
+
+{
+ struct STUFF *stuff2_p; /* point along STUFF list */
+
+
+ debug(32, "rmstuff file=%s line=%d", stuff_p->inputfile,
+ stuff_p->inputlineno);
+ if (staff_p->stuff_p == stuff_p) {
+ /* the given stuff is the first one in the list */
+ staff_p->stuff_p = stuff_p->next;
+ } else {
+ /* find which stuff in list points at the one to be removed */
+ for (stuff2_p = staff_p->stuff_p; stuff2_p->next != stuff_p;
+ stuff2_p = stuff2_p->next)
+ ;
+ stuff2_p->next = stuff_p->next;
+ }
+
+ FREE(stuff_p);
+}
+\f
+/*
+ * Name: breakstuff()
+ *
+ * Abstract: Break all "stuff" that crosses scorefeeds.
+ *
+ * Returns: void
+ *
+ * Description: This function loops through the main linked list and all STUFF,
+ * looking for stuff that crosses score feeds. When it finds such
+ * stuff, it breaks them at that point.
+ */
+
+static void
+breakstuff()
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+
+
+ debug(16, "breakstuff");
+ initstructs();
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* keep SSVs up to date; we need to know time sig */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+
+ case S_STAFF:
+ /* break out to handle this STAFF */
+ break;
+
+ default:
+ /* nothing to do, skip to next loop */
+ continue;
+ }
+
+ /*
+ * Loop through all the stuff on this staff. Do it in reverse
+ * order so that when stuff gets broken, the new STUFFs end up
+ * in the correct order.
+ */
+ if (mainll_p->u.staff_p->stuff_p != 0) {
+
+ stuff_p = mainll_p->u.staff_p->stuff_p;
+ while (stuff_p->next != 0)
+ stuff_p = stuff_p->next;
+ /* now stuff_p points at the last one in the list */
+
+ for ( ; stuff_p != 0; stuff_p = prevstuff(mainll_p,
+ stuff_p)) {
+ /*
+ * If there's a "til" clause, and it crosses
+ * bar lines, call a function to see if it
+ * needs to be broken, and if so, break it.
+ */
+ if (stuff_p->end.bars > 0)
+ breakone(mainll_p, stuff_p,
+ Score.timenum,
+ stuff_p->string, 1);
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: prevstuff()
+ *
+ * Abstract: Find stuff preceding the given one.
+ *
+ * Returns: pointer to previous stuff, or 0 if none
+ *
+ * Description: This function is given a pointer to a staff mainll item and a
+ * stuff in that list. It finds the preceding stuff, returning
+ * it, or 0 if none. If stuff linked lists were doubly linked,
+ * we wouldn't have to go through this aggravation.
+ */
+
+static struct STUFF *
+prevstuff(mainll_p, stuff_p)
+
+struct MAINLL *mainll_p; /* ptr to MLL item for a stuff */
+struct STUFF *stuff_p; /* ptr to current stuff */
+
+{
+ register struct STUFF *prevstuff_p;
+
+
+ prevstuff_p = mainll_p->u.staff_p->stuff_p; /* get 1st stuff in list */
+
+ /* if current stuff is first stuff, there is none before it */
+ if (prevstuff_p == stuff_p)
+ return (0);
+
+ /* loop until we find it, then return */
+ while (prevstuff_p->next != stuff_p)
+ prevstuff_p = prevstuff_p->next;
+ return (prevstuff_p);
+}
+\f
+/*
+ * Name: breakone()
+ *
+ * Abstract: Break one "stuff" item if it crosses scorefeeds.
+ *
+ * Returns: void
+ *
+ * Description: This function is given a STUFF with a "til" clause that crosses
+ * bar line(s). It finds out if the STUFF crosses the FEED at the
+ * end of the score. If so, it stops the current stuff there, and
+ * starts a continuation on the next score. If there are more bar
+ * lines yet to be crossed, it calls itself recursively.
+ */
+
+static void
+breakone(mllstaff_p, stuff_p, timenum, origstr_p, depth)
+
+struct MAINLL *mllstaff_p; /* point at MLL struct holding stuff's staff */
+struct STUFF *stuff_p; /* point at a STUFF structure */
+int timenum; /* numerator of current time sig */
+char *origstr_p; /* original string, from first score of stuff */
+int depth; /* depth of recursion */
+
+{
+ /*
+ * Make the local variables static, to use less stack when making
+ * recursive calls. We can get away with this because the recursive
+ * call is at the end of the function, and the variables aren't used
+ * after that.
+ */
+ static struct MAINLL *m2_p; /* point along main linked list */
+ static struct MAINLL *m3_p; /* point along main linked list */
+ static struct MAINLL *m4_p; /* point along main linked list */
+ static struct STUFF *s_p; /* point at a new STUFF */
+ static struct GRPSYL *gs_p; /* point along a GRPSYL list */
+ static int bars; /* count how many bars long it is */
+ static int otimenum; /* num of time sig before last bar */
+ static float endcount; /* count where the stuff ends */
+
+
+ debug(32, "breakone file=%s line=%d timenum=%d origstr_p=\"%s\"",
+ stuff_p->inputfile, stuff_p->inputlineno, timenum,
+ origstr_p == 0 ? "" : origstr_p);
+ /*
+ * Save how many bars this stuff crosses (initially, before any
+ * breaking), and the count where it ends.
+ */
+ bars = stuff_p->end.bars;
+ endcount = stuff_p->end.count;
+
+ /*
+ * Loop forward until crossing the given number of bars, or hitting a
+ * FEED, whichever comes first. Keep the timenum updated. At each
+ * bar line, save what it was before in otimenum.
+ */
+ for (m2_p = mllstaff_p; bars >= 0 && m2_p != 0 && m2_p->str != S_FEED;
+ m2_p = m2_p->next) {
+
+ switch (m2_p->str) {
+ case S_SSV:
+ if (m2_p->u.ssv_p->used[TIME] == YES)
+ timenum = m2_p->u.ssv_p->timenum;
+ break;
+
+ case S_BAR:
+ otimenum = timenum;
+ bars--;
+ break;
+
+ case S_STAFF:
+ /*
+ * If this is the first staff of a measure, check the
+ * first voice to see if it's a multirest. (If it is,
+ * all voices on all staffs would be.) If so, decrement
+ * the bars remaining appropriately. It could end up
+ * less than 0. That's okay; we won't be breaking it.
+ */
+ if (m2_p->u.staff_p->staffno == 1 &&
+ m2_p->u.staff_p->groups_p[0]->basictime < -1) {
+
+ bars += 1 + m2_p->u.staff_p->
+ groups_p[0]->basictime;
+ }
+ break;
+ }
+ }
+
+ /*
+ * If bars <= -1, this stuff doesn't reach the end of this score, so
+ * just return. If we hit the end of the piece, end the stuff at the
+ * last count of the last measure (thus the last bar line). The
+ * parser has already put out a warning for this.
+ * If the stuff ends at the pseudobar of the next score, make it end at
+ * the last bar of this score instead. However, phrases should not be
+ * adjusted this way, because under these conditions they will get
+ * pulled to the note at count 1.
+ */
+ if (bars <= -1)
+ return;
+ if (m2_p == 0 || bars == 0 && stuff_p->end.count == 0 &&
+ stuff_p->stuff_type != ST_PHRASE) {
+ stuff_p->end.bars -= bars + 1;
+ stuff_p->end.count = timenum + 1;
+ return;
+ }
+
+ /*
+ * At this point we know that the stuff truly crosses the FEED we're
+ * at, and we're going to have to break it. First, terminate the part
+ * of the stuff on this score and mark the carryout. (However, if the
+ * next staff starts with a multirest that fully contains the rest of
+ * the stuff, we'll cancel the carryout later and not insert a new
+ * stuff for continuation.)
+ */
+ stuff_p->end.bars -= bars + 1; /* only cross this many bars */
+ stuff_p->end.count = otimenum + 1; /* end at end of last measure*/
+ stuff_p->carryout = YES;
+
+ /*
+ * Find the matching STAFF in the next measure. It might not exist
+ * due to blocks.
+ */
+ for (m3_p = m2_p->next; m3_p != 0 && m3_p->str != S_BAR;
+ m3_p = m3_p->next) {
+ if (m3_p->str == S_STAFF && m3_p->u.staff_p->staffno ==
+ mllstaff_p->u.staff_p->staffno)
+ break;
+ }
+ if (m3_p == 0) {
+ return;
+ }
+ if (m3_p->str != S_STAFF)
+ pfatal("can't find staff in main linked list [breakone]");
+
+ /*
+ * If the staff has a multirest that's longer than the remaining
+ * length of the stuff, don't insert a new stuff; just get out now.
+ */
+ if (m3_p->u.staff_p->groups_p[0]->basictime < -1) {
+ if (bars < -(m3_p->u.staff_p->groups_p[0]->basictime)) {
+ stuff_p->carryout = NO; /* cancel the carryout */
+ return;
+ }
+ }
+
+ /*
+ * Create a new STUFF starting at count 0 of the new measure. Link it
+ * in to its STAFF and set fields appropriately.
+ */
+ s_p = newSTUFF(origstr_p, stuff_p->dist, stuff_p->dist_usage,
+ (double)0, (double)0, (short)0, bars, endcount,
+ stuff_p->stuff_type, stuff_p->modifier, stuff_p->place,
+ stuff_p->inputfile, stuff_p->inputlineno);
+ s_p->next = m3_p->u.staff_p->stuff_p;
+ m3_p->u.staff_p->stuff_p = s_p;
+ s_p->carryin = YES;
+ s_p->vno = stuff_p->vno; /* actually only needed for phrases */
+
+ switch (s_p->stuff_type) {
+ case ST_ROM:
+ case ST_BOLD:
+ case ST_ITAL:
+ case ST_BOLDITAL:
+ /*
+ * If this staff was visible on the previous score, we just
+ * want the continuation dashes on this score, not the original
+ * string, so we change the string in that case. (If the staff
+ * is also invisible on this score, we don't care what happens,
+ * so don't even check for that.) Otherwise, leave it alone.
+ * Also, all other types that have strings should always repeat
+ * them on each score, so leave them alone.
+ */
+ if (mllstaff_p->u.staff_p->visible == YES)
+ s_p->string = dashstr(stuff_p->string);
+ break;
+ case ST_PHRASE:
+ /*
+ * The new (2nd half of the) phrase mark has as its first group
+ * its voice's first GRPSYL in the new score. Its last group
+ * is the last GRPSYL of the entire phrase. The last group of
+ * the old (1st half of the) phrase mark is the last GRPSYL on
+ * that score for this voice.
+ */
+ s_p->beggrp_p = m3_p->u.staff_p->groups_p[ stuff_p->vno - 1 ];
+ s_p->endgrp_p = stuff_p->endgrp_p;
+ /* find matching staff in the measure before the FEED */
+ for (m4_p = m2_p; m4_p->str != S_STAFF ||
+ m4_p->u.staff_p->staffno !=
+ mllstaff_p->u.staff_p->staffno;
+ m4_p = m4_p->prev)
+ ;
+ /* find last group in the measure in that voice */
+ for (gs_p = m4_p->u.staff_p->groups_p[ stuff_p->vno - 1 ];
+ gs_p->next != 0; gs_p = gs_p->next)
+ ;
+ stuff_p->endgrp_p = gs_p;
+ break;
+ }
+
+ /*
+ * If there are still more bars to be crossed, call ourselves
+ * recursively to break the stuff again if necessary. But first check
+ * to see we aren't too deep in recursion, using too much stack.
+ */
+ if (s_p->end.bars > 0) {
+ if (depth >= 300)
+ l_ufatal(stuff_p->inputfile, stuff_p->inputlineno,
+ "stuff crosses more than 300 scores (break into shorter pieces)");
+ breakone(m3_p, s_p, timenum, origstr_p, depth + 1);
+ }
+}
+\f
+/*
+ * Name: contpedal()
+ *
+ * Abstract: Insert pedal continuation STUFFs when needed.
+ *
+ * Returns: void
+ *
+ * Description: When a pedal is to be held down through a score feed, the
+ * print phase needs to know where (vertically) to draw the pedal
+ * line on the new score. There might not occur another pedal
+ * character in the first measure there, or even on that whole
+ * score. So whenever this happens, regardless of whether there
+ * are already pedal characters on the new score, this function
+ * inserts a new STUFF with a special, null pedal indication, at
+ * count 0 of the first measure of the new score.
+ */
+
+static void
+contpedal()
+
+{
+ short inpedal[MAXSTAFFS + 1]; /* does this staff have pedal on now?*/
+ short snappedal[MAXSTAFFS + 1]; /* same, when an ending is entered */
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct MAINLL *m2_p; /* another pointer along MLL */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct STUFF *stuff2_p; /* point at new STUFF structure */
+ struct BAR *bar_p; /* point at a bar line */
+ int inending; /* are we now in an ending? */
+ int s; /* staff number */
+
+
+ debug(16, "contpedal");
+ /* init pedal state to NO for all staffs */
+ for (s = 1; s <= MAXSTAFFS; s++)
+ inpedal[s] = NO;
+
+ inending = NO;
+
+ /*
+ * Loop through main linked list. For each STAFF found, update pedal
+ * state when necessary. For each FEED found, if there's a pedal
+ * crossing it, insert a pedal continuation. There is special work to
+ * do when endings are encountered, since this can change pedal states.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+
+ case S_STAFF:
+ /*
+ * Loop through all the stuff on this staff. Whenever
+ * there's a pedal mark, update the state for that
+ * staff, except that pedal up/down is irrelevant.
+ */
+ for (stuff_p = mainll_p->u.staff_p->stuff_p;
+ stuff_p != 0; stuff_p = stuff_p->next) {
+
+ if (stuff_p->stuff_type != ST_PEDAL)
+ continue;
+
+ if (string_is_sym(stuff_p->string,
+ C_BEGPED, FONT_MUSIC) == YES)
+ inpedal[mainll_p->u.staff_p->
+ staffno] = YES;
+
+ else if (string_is_sym(stuff_p->string,
+ C_ENDPED, FONT_MUSIC) == YES)
+ inpedal[mainll_p->u.staff_p->
+ staffno] = NO;
+ }
+ break;
+
+ case S_BAR:
+ /*
+ * When entering a second or later ending, the state of
+ * all pedals must be set back to what they were when
+ * entering the first ending.
+ * First deal with the case where an ending starts at
+ * the pseudobar after a feed. In that case, we need
+ * to ignore any endending on the previous real bar.
+ */
+ bar_p = mainll_p->u.bar_p;
+ for (m2_p = mainll_p->next; m2_p != 0 &&
+ m2_p->str != S_BAR &&
+ (m2_p->str != S_CLEFSIG ||
+ m2_p->u.clefsig_p->bar_p == 0);
+ m2_p = m2_p->next)
+ ;
+ if (m2_p != 0 && m2_p->str == S_CLEFSIG) {
+ /*
+ * If an ending starts at this pseudobar,
+ * substitute this pseudobar for the real one.
+ */
+ if (m2_p->u.clefsig_p->bar_p->endingloc
+ == STARTITEM)
+ bar_p = m2_p->u.clefsig_p->bar_p;
+ }
+
+ switch (bar_p->endingloc) {
+ case STARTITEM:
+ if (inending == NO) {
+ /* entering first ending */
+ /* snapshot pedal states here */
+ for (s = 1; s <= MAXSTAFFS; s++)
+ snappedal[s] = inpedal[s];
+ inending = YES;
+ } else {
+ /* entering a later ending */
+ /* restore snapshotted state */
+ for (s = 1; s <= MAXSTAFFS; s++)
+ inpedal[s] = snappedal[s];
+ }
+ break;
+
+ case ENDITEM:
+ /* leaving the last ending */
+ inending = NO;
+ break;
+ }
+ break;
+
+ case S_FEED:
+ /* only consider FEEDs that are before music */
+ if ( ! IS_CLEFSIG_FEED(mainll_p)) {
+ break;
+ }
+
+ /*
+ * For every staff where the pedal is now down, find
+ * the structure for that staff in the first measure,
+ * and insert a STUFF to indicate the continuation of
+ * the pedal mark line.
+ */
+ for (s = 1; s <= MAXSTAFFS; s++) {
+
+ if (inpedal[s] == NO)
+ continue;
+
+ for (m2_p = mainll_p; m2_p != 0 &&
+ (m2_p->str != S_STAFF ||
+ m2_p->u.staff_p->staffno != s);
+ m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ pfatal("couldn't find staff in contpedal");
+ /* pedal continuation at count 0, w/ null str */
+ stuff2_p = newSTUFF((char *)0, 0, SD_NONE,
+ (double)0, (double)0, (short)0, 0,
+ (double)0, ST_PEDAL, NO, PL_BELOW,
+ (char *)0, -1);
+
+ /* put at beginning of staff's linked list */
+ stuff2_p->next = m2_p->u.staff_p->stuff_p;
+ m2_p->u.staff_p->stuff_p = stuff2_p;
+ }
+ break;
+ }
+ }
+}
+\f
+/*
+ * Name: setstuff()
+ *
+ * Abstract: Set horizontal absolute coordinates of "stuff".
+ *
+ * Returns: void
+ *
+ * Description: This function loops through the main linked list. For every
+ * visible staff, it loops through its list of STUFF structures,
+ * setting all their absolute horizontal coordinates.
+ */
+
+static void
+setstuff()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct CHHEAD *chhead_p; /* chord headcell of current measure */
+ struct BAR *bar_p; /* [pseudo] bar before current meas */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct MAINLL *m2_p; /* MLL for end of stuff */
+ short timeden2; /* time sig denom at end of stuff */
+ struct CHHEAD *chhead2_p; /* chord headcell for end of stuff */
+ struct BAR *bar2_p; /* bar line for end of stuff */
+ struct GRPSYL *gs_p; /* used for gracebackup */
+ float stepsize; /* STEPSIZE scaled by staffscale */
+ float leftwid; /* width of string left of align pt. */
+ float streast; /* east end of a string */
+ int ret; /* return code from geteast */
+ int v; /* voice associated with */
+ int n; /* loop variable */
+
+
+ debug(16, "setstuff");
+ initstructs();
+
+ chhead_p = 0; /* prevent useless 'used before set' warning */
+ bar_p = 0; /* prevent useless 'used before set' warning */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ /*
+ * Do various set up work per structure type. If it's a
+ * visible staff, break and go do the rest of this loop.
+ * Otherwise, "continue" on to the next structure.
+ */
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* keep SSVs up to date; we need to know timeden */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+
+ case S_CHHEAD:
+ /* always remember preceding chord headcell */
+ chhead_p = mainll_p->u.chhead_p;
+ continue;
+
+ case S_BAR:
+ /* always remember where the preceding bar was */
+ bar_p = mainll_p->u.bar_p;
+ continue;
+
+ case S_CLEFSIG:
+ /*
+ * The pseudo bar that's in a clefsig following a
+ * scorefeed overrides the real bar at the end of the
+ * previous score.
+ */
+ if (mainll_p->u.clefsig_p->bar_p != 0)
+ bar_p = mainll_p->u.clefsig_p->bar_p;
+ continue;
+
+ case S_STAFF:
+ /* visible staff breaks out to do rest of the loop */
+ if (mainll_p->u.staff_p->visible == YES)
+ break;
+ continue;
+
+ default:
+ continue;
+ }
+
+ /* get stepsize for this staff */
+ stepsize = STEPSIZE * svpath(mainll_p->u.staff_p->staffno,
+ STAFFSCALE)->staffscale;
+
+ /*
+ * Loop through all the stuff on this staff.
+ */
+ for (stuff_p = mainll_p->u.staff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ /*
+ * Handle the special case of a fermata on a measure
+ * rest. No matter what count the user requested,
+ * we're going to center it above or below the measure
+ * rest character. We also assume there is no "til"
+ * clause.
+ */
+ if (string_is_sym(stuff_p->string, C_FERM, FONT_MUSIC) == YES ||
+ string_is_sym(stuff_p->string, C_UFERM, FONT_MUSIC) == YES) {
+
+ if (setmrferm(mainll_p->u.staff_p, stuff_p)
+ == YES)
+ continue;
+ /*
+ * The fermata is not on a measure rest. Fall
+ * through to handle like any normal stuff.
+ */
+ }
+
+ /*
+ * Set c[AX] for the stuff.
+ */
+ if (stuff_p->gracebackup == 0) {
+ /*
+ * Use the c[INCHPERWHOLE] coordinate of the
+ * chord or bar line that is at or before its
+ * "start".
+ */
+ stuff_p->c[AX] = count2coord(
+ stuff_p->start.count, bar_p, chhead_p,
+ Score.timeden) +
+ stuff_p->start.steps *
+ STUFFSTEP(stuff_p);
+ } else {
+ /*
+ * Since we have to back up by some number of
+ * grace notes, we have to find a group to
+ * associate the STUFF with. Then we can back
+ * up from there.
+ */
+ v = 0; /* avoid 'used before set' warning */
+ switch (svpath(mainll_p->u.staff_p->staffno,
+ VSCHEME)->vscheme) {
+ case V_1: /* 1 */
+ v = 0; /* only one voice, use it */
+ break;
+ case V_2FREESTEM: /* 2f */
+ case V_3FREESTEM: /* 3f */
+ if (chkallspace(mainll_p, stuff_p, 0)
+ == YES) {
+ /* first voice all spaces */
+ /* apply stuff to second */
+ v = 1;
+ break;
+ } else if (chkallspace(mainll_p,
+ stuff_p, 1) == YES) {
+ /* second voice all spaces */
+ /* apply stuff to first */
+ v = 0;
+ break;
+ }
+ /* FALL THROUGH;handle like V_2OPSTEM */
+ case V_2OPSTEM: /* 2o */
+ case V_3OPSTEM: /* 3o */
+ v = stuff_p->place == PL_ABOVE ? 0 : 1;
+ break;
+ }
+
+ /* find closest note group in this voice */
+ gs_p = closestgroup(stuff_p->start.count,
+ mainll_p->u.staff_p->groups_p[v],
+ Score.timeden);
+
+ /* back up right number of grace groups */
+ for (n = 0; n < stuff_p->gracebackup; n++) {
+ gs_p = gs_p->prev;
+ if (gs_p == 0 || gs_p->grpvalue
+ != GV_ZERO)
+ l_ufatal(stuff_p->inputfile,
+ stuff_p->inputlineno,
+ "not enough grace groups to back up to for stuff");
+ }
+
+ /*
+ * Put the stuff at this grace group, except
+ * that the steps offset must be applied.
+ */
+ stuff_p->c[AX] = gs_p->c[AX] +
+ stuff_p->start.steps *
+ STUFFSTEP(stuff_p);
+ }
+
+ /*
+ * If this stuff has a "til" clause, find where the
+ * ending point is and set c[AE] to that. If this
+ * stuff also has a string, and the string extends
+ * beyond the point that the "til" clause asks for,
+ * c[AE] will be changed later to agree with the string.
+ */
+ if (stuff_p->end.bars != 0 || stuff_p->end.count != 0) {
+ /*
+ * Init variables to the current position
+ * (beginning of the stuff). If the stuff is
+ * supposed to extend across one or more bar
+ * lines, geteast() will alter them to the
+ * correct values for the bar where the stuff
+ * ends. It will blow away the 'til' clause in
+ * certain multirest scenarios.
+ */
+ m2_p = mainll_p; /* this stuff's staff*/
+ timeden2 = Score.timeden;
+ chhead2_p = chhead_p;
+ bar2_p = bar_p;
+
+ ret = geteast(stuff_p, m2_p, &timeden2,
+ &chhead2_p, &bar2_p);
+
+ switch (ret) {
+ case 1:
+ /*
+ * Set c[AE] for the stuff, using the
+ * c[INCHPERWHOLE] coordinate of the
+ * chord or bar line that precedes or
+ * is at the end of it.
+ */
+ stuff_p->c[AE] = count2coord(
+ stuff_p->end.count,
+ bar2_p, chhead2_p, timeden2);
+ break;
+ case 2:
+ /* end the stuff a little beyond the */
+ /* barline at the start of the stuff */
+ stuff_p->c[AE] = bar2_p->c[AX]
+ + STUFFSTEP(stuff_p);
+ break;
+ case 3:
+ /* no "til" clause anymore */
+ /* set to 0 temporarily */
+ stuff_p->c[AE] = 0;
+ break;
+ }
+ /*
+ * If there is still a "til" clause (it wasn't
+ * blown away), make sure AE isn't left of AX.
+ * Although the parse phase checks the bars and
+ * counts for this, it could still happen here
+ * if start.steps is too big. If it happens,
+ * warn, and set AE to AX.
+ */
+ if (stuff_p->end.bars != 0 ||
+ stuff_p->end.count != 0) {
+ if (stuff_p->c[AE] < stuff_p->c[AX]) {
+ l_warning(stuff_p->inputfile,
+ stuff_p->inputlineno,
+ "mark begins after 'til' position; moving 'til' position to the right");
+ stuff_p->c[AE] = stuff_p->c[AX];
+ }
+ }
+ } else {
+ /* no "til" clause; set to 0 temporarily */
+ stuff_p->c[AE] = 0;
+ }
+
+ /*
+ * Set c[AW] for all stuff types, and c[AE] for ones
+ * that don't have a "til" clause. Reset c[AE] for
+ * ones that have a "til" clause, if they have a string
+ * that sticks out farther than that.
+ */
+ switch (stuff_p->stuff_type) {
+ case ST_ROM:
+ case ST_BOLD:
+ case ST_ITAL:
+ case ST_BOLDITAL:
+ case ST_MUSSYM:
+ case ST_PEDAL:
+ case ST_OCTAVE:
+ /*
+ * These types (and only these) have a string.
+ * (However, pedal continuations don't, so
+ * treat them specially.) Set c[AW] such that
+ * the first character will be centered at
+ * c[AX].
+ */
+ if (stuff_p->string == 0) {
+ /* must be a pedal continuation; */
+ /* these have no width */
+ stuff_p->c[AW] = stuff_p->c[AE] =
+ stuff_p->c[AX];
+ break;
+ }
+
+ /* not a pedal continuation */
+
+ /*
+ * If this is a chord with a grid, handle it
+ * all in the subroutine.
+ */
+ if (stuff_p->modifier == TM_CHORD && trygrid(
+ mainll_p, stuff_p) == YES) {
+ break;
+ }
+
+ leftwid = left_width(stuff_p->string);
+ stuff_p->c[AW] = stuff_p->c[AX] - leftwid;
+
+ /* find the initial east of the string */
+ streast = stuff_p->c[AW] +
+ strwidth(stuff_p->string);
+ /*
+ * If the string would go beyond the right
+ * margin, try to split it onto multiple lines,
+ * and reset the string's east. Don't do this
+ * for chord/analysis/figbass.
+ */
+ if (streast > PGWIDTH -
+ eff_rightmargin(mainll_p) &&
+ ! IS_CHORDLIKE(stuff_p->modifier)) {
+ stuff_p->string = split_string(
+ stuff_p->string, PGWIDTH -
+ eff_rightmargin(mainll_p) -
+ stuff_p->c[AW]);
+ streast = stuff_p->c[AW] +
+ strwidth(stuff_p->string);
+ }
+
+ /*
+ * If this east is beyond the east given by the
+ * "til" clause (if any), use it for the AE.
+ */
+ if (streast > stuff_p->c[AE])
+ stuff_p->c[AE] = streast;
+
+ break;
+
+ case ST_CRESC:
+ case ST_DECRESC:
+ case ST_PHRASE:
+ case ST_TIESLUR: /* due to carry-in into ending */
+ case ST_TABSLUR: /* due to carry-in into ending */
+ case ST_BEND: /* due to carry-in into ending */
+ /*
+ * These types (and only these) have no string.
+ * Set c[AW] the same as c[AX]. These always
+ * have "til" clauses, so c[AE] is already set.
+ * (Actually, c[AE] is not set for TIESLUR,
+ * TABSLUR, or BEND, but no one uses it anyhow.)
+ */
+ stuff_p->c[AW] = stuff_p->c[AX];
+ break;
+
+ case ST_MIDI:
+ /* this file doesn't deal with MIDI at all */
+ break;
+
+ default:
+ pfatal("unknown stuff type %d",
+ stuff_p->stuff_type);
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: count2coord()
+ *
+ * Abstract: Convert a count in a measure to the absolute horizontal coord.
+ *
+ * Returns: coordinate corresponding to the given count
+ *
+ * Description: This function, given a count number in a measure, and the
+ * preceding bar line, chord head cell, and time signature
+ * denominator, calculates and returns the absolute horizonal
+ * coordinate of that place. In a measure, the preceding bar line
+ * (or pseudo bar line, if this is the first measure of a score)
+ * is regarded as count 0, and the following bar line is regarded
+ * as count N + 1, where N is the numerator of the time signature.
+ * Between any adjacent chords, or chord and bar line, time is
+ * treated as proportional to distance.
+ */
+
+static double
+count2coord(count, bar_p, chhead_p, timeden)
+
+double count; /* count in measure */
+struct BAR *bar_p; /* bar at start of measure (pseudobar if 1st in score)*/
+struct CHHEAD *chhead_p;/* chord headcell for this measure */
+int timeden; /* denominator of time signature in this measure */
+
+{
+ struct CHORD *ch_p, *nch_p; /* point at CHORD structures */
+ float frac; /* what fraction of a whole it starts at */
+ float coord; /* the answer */
+
+
+ if (count < 1) {
+ /*
+ * The stuff is before the first chord ("count 1"). So we
+ * consider the preceding bar line to be count 0, and allocate
+ * time proportionally.
+ */
+ coord = bar_p->c[AX] + (count / timeden) *
+ bar_p->c[INCHPERWHOLE];
+ } else {
+ /*
+ * Convert the "count" where this stuff begins to what fraction
+ * of a whole it starts at.
+ */
+ frac = (count - 1) / timeden;
+
+ /*
+ * In this loop, ch_p starts at the first chord and nch_p is
+ * the next chord. They move forward in parallel. We get out
+ * either when nch_p is 0 (ch_p is the last chord), or when
+ * nch_p is beyond the place where our stuff goes (the stuff
+ * goes at or following ch_p).
+ */
+ for (ch_p = chhead_p->ch_p, nch_p = ch_p->ch_p;
+ nch_p != 0 && RAT2FLOAT(nch_p->starttime) <= frac;
+ ch_p = nch_p, nch_p = nch_p->ch_p)
+ ;
+
+ /*
+ * Subtract to find how far (timewise) the stuff is after chord
+ * ch_p. Then allocate space proportionally.
+ */
+ coord = ch_p->c[AX] + (frac - RAT2FLOAT(ch_p->starttime)) *
+ ch_p->c[INCHPERWHOLE];
+ }
+
+ return (coord);
+}
+\f
+/*
+ * Name: geteast()
+ *
+ * Abstract: Point variables at things relevant to the east end of a STUFF.
+ *
+ * Returns: 1 if count2coord() should be used to find AE of stuff
+ * 2 if AE of stuff should be near *bar_p_p due to multirest
+ * 3 if 'til' clause is being blown away due to multirest
+ *
+ * Description: This function is given pointers pertaining to a measure where
+ * a STUFF begins. It searches forward to the end of the stuff,
+ * according to the given number of measures. It sets *timeden2_p,
+ * *chhead2_p_p, and *bar2_p_p to the values they should be for
+ * the end of the stuff, if the return code is 1 (the usual case).
+ * For 2 and 3, only *bar2_p_p is guaranteed to be meaningful.
+ */
+
+static int
+geteast(stuff_p, m2_p, timeden2_p, chhead2_p_p, bar2_p_p)
+
+struct STUFF *stuff_p; /* pointer to the stuff */
+struct MAINLL *m2_p; /* starts at start of stuff, change to end */
+short *timeden2_p; /* starts at start of stuff, change to end */
+struct CHHEAD **chhead2_p_p; /* starts at start of stuff, change to end */
+struct BAR **bar2_p_p; /* starts at start of stuff, change to end */
+
+{
+ int blimit; /* number of bars to search forward past */
+ int timenum; /* numerator of time signature */
+ int b; /* count bar lines */
+
+
+ blimit = stuff_p->end.bars; /* number of bars to cross */
+
+ /* if all within one bar, return right away */
+ if (blimit == 0) {
+ /* if starts and ends inside multirest, blow away 'til' clause*/
+ if (m2_p->u.staff_p->groups_p[0]->basictime < -1) {
+ stuff_p->end.count = 0;
+ return (3);
+ }
+
+ return (1); /* normal case; retain 'til' clause */
+ }
+
+ timenum = Score.timeden; /* keep track of time sig numerator */
+
+ /*
+ * The input parameters point at values that are for the beginning of
+ * the stuff. Loop forward the requested number of bars to get to the
+ * end of the stuff. While doing this, keep those variables updated.
+ * By the end of this function, they will be correct for the end of
+ * the stuff.
+ */
+ b = 0;
+ /* if it starts at a multirest, account for that */
+ if (m2_p->u.staff_p->groups_p[0]->basictime < -1) {
+ /* if it ends inside the multirest, point at previous bar, */
+ /* blow away 'til' clause, and get out */
+ if (-(m2_p->u.staff_p->groups_p[0]->basictime) > blimit) {
+ *bar2_p_p = m2_p->u.bar_p;
+ stuff_p->end.bars = 0;
+ stuff_p->end.count = 0;
+ return (3);
+ }
+
+ b = -1 - m2_p->u.staff_p->groups_p[0]->basictime;
+ }
+ for ( ; b < blimit; b++) {
+ for (m2_p = m2_p->next; m2_p != 0 && m2_p->str != S_BAR;
+ m2_p = m2_p->next) {
+
+ switch (m2_p->str) {
+ case S_SSV:
+ if (m2_p->u.ssv_p->used[TIME] == YES) {
+ timenum = m2_p->u.ssv_p->timenum;
+ *timeden2_p = m2_p->u.ssv_p->timeden;
+ }
+ break;
+
+ case S_STAFF:
+ /* multirests count as multiple measures */
+ if (m2_p->u.staff_p->staffno == 1 &&
+ m2_p->u.staff_p->groups_p[0]->basictime < -1) {
+
+ /* add (multi - 1) to no. of bars */
+ b -= 1 + m2_p->u.staff_p->
+ groups_p[0]->basictime;
+
+ /*
+ * If the stuff doesn't make it into
+ * the last measure, or doesn't make it
+ * to the last measure's bar line, make
+ * it stop at the bar before multirest.
+ */
+ if (b > blimit || b == blimit &&
+ stuff_p->end.count < timenum + 1) {
+ return (2);
+ }
+
+ /*
+ * If it ends at the bar after the
+ * multirest, move forward to that bar
+ * and end the stuff there.
+ */
+ if (b == blimit) {
+ while (m2_p->str != S_BAR)
+ m2_p = m2_p->next;
+ *bar2_p_p = m2_p->u.bar_p;
+ return (2);
+ }
+ }
+ break;
+ }
+ }
+
+ if (m2_p == 0)
+ pfatal("'til' clause extends beyond end of the piece [geteast1]");
+
+ *bar2_p_p = m2_p->u.bar_p;
+ }
+
+ /*
+ * m2_p points at the bar line preceding or at the place where the
+ * stuff ends. Continue forward to be pointing at the CHHEAD of that
+ * measure and also do final variable updates.
+ */
+ for ( ; m2_p != 0 && m2_p->str != S_CHHEAD;
+ m2_p = m2_p->next) {
+
+ switch (m2_p->str) {
+ case S_SSV:
+ if (m2_p->u.ssv_p->used[TIME] == YES)
+ *timeden2_p = m2_p->u.ssv_p->timeden;
+ break;
+ case S_CLEFSIG:
+ if (m2_p->u.clefsig_p->bar_p != 0)
+ *bar2_p_p = m2_p->u.clefsig_p->bar_p;
+ break;
+ }
+ }
+
+ if (m2_p == 0)
+ pfatal("'til' clause extends beyond end of the piece [geteast2]");
+
+ /*
+ * If the first staff in this measure has a multirest, return that fact
+ * and have the stuff end at this bar line.
+ */
+ if (m2_p->next->u.staff_p->groups_p[0]->basictime < -1)
+ return (2);
+
+ *chhead2_p_p = m2_p->u.chhead_p;
+
+ return (1); /* didn't end during a multirest */
+}
+\f
+/*
+ * Name: setmrferm()
+ *
+ * Abstract: Set absolute horizonal coords of a fermata on measure rest/rpt.
+ *
+ * Returns: YES or NO
+ *
+ * Description: This function is given a staff and a stuff for a fermata there.
+ * It decides whether the fermata applies to a measure rest or a
+ * measure repeat. If it does, it sets its coords to align with
+ * the symbol and returns YES. Otherwise it returns NO.
+ */
+
+static int
+setmrferm(staff_p, stuff_p)
+
+struct STAFF *staff_p;
+struct STUFF *stuff_p;
+
+{
+ struct GRPSYL *gs_p; /* point at the relevant grpsyl list */
+ float fermx; /* the center of the fermata */
+ float fermwidth; /* width of the fermata */
+ int font, size, code; /* of the fermata */
+ char *s_p; /* point into the string holding the fermata */
+
+
+ debug(32, "setmrferm file=%s line=%d", stuff_p->inputfile,
+ stuff_p->inputlineno);
+ /*
+ * Who knows why the user would put a fermata between two staffs, but
+ * if they did, treat it as normal stuff.
+ */
+ if (stuff_p->place == PL_BETWEEN)
+ return (NO);
+
+ /*
+ * Figure out which voice this fermata is meant to apply to. It could
+ * be that one voice has a measure rest and the other doesn't. For
+ * measure repeats, both would have it, so we wouldn't care which
+ * voice, but we might as well fall through the same code. Point
+ * at the first GRPSYL in that voice's list.
+ */
+ gs_p = 0; /* prevent useless 'used before set' warning */
+ switch (svpath(staff_p->staffno, VSCHEME)->vscheme) {
+ case V_1:
+ /* only 1 voice, this must be it */
+ gs_p = staff_p->groups_p[0];
+ break;
+
+ case V_2OPSTEM:
+ case V_3OPSTEM:
+ /*
+ * Technically we should attach the fermata to the voice it is
+ * next to. But if that voice is all spaces, that wouldn't
+ * make much sense. So fall through and handle the same as
+ * the freestem cases.
+ */
+
+ case V_2FREESTEM:
+ case V_3FREESTEM:
+ /* apply it to the nearest voice, unless it's all spaces */
+ if (stuff_p->place == PL_ABOVE) {
+ if ( ! hasspace(staff_p->groups_p[0], Zero, Score.time))
+ gs_p = staff_p->groups_p[0];
+ else
+ gs_p = staff_p->groups_p[1];
+ } else {
+ if ( ! hasspace(staff_p->groups_p[1], Zero, Score.time))
+ gs_p = staff_p->groups_p[1];
+ else
+ gs_p = staff_p->groups_p[0];
+ }
+ break;
+ }
+
+ /*
+ * If the relevant voice is not a measure rest or measure repeat, don't
+ * do anything more. Just return and let the normal "stuff" code
+ * handle this fermata.
+ */
+ if (gs_p->is_meas == NO)
+ return (NO);
+
+ /*
+ * This fermata is on a measure rest/repeat. We can't rely on the AX
+ * of this; it's offset like a whole rest would be. We have to
+ * average the AW and AE to know where the center should be.
+ * If the user requested a stepsize offset, we will apply it to the
+ * result, so in that case it won't really be centered after all.
+ */
+ fermx = (gs_p->c[AW] + gs_p->c[AE]) / 2 +
+ stuff_p->start.steps * STEPSIZE;
+
+ /* find width of fermata */
+ font = stuff_p->string[0];
+ size = stuff_p->string[1];
+ s_p = &stuff_p->string[2];
+ code = next_str_char(&s_p, &font, &size);
+ fermwidth = width(font, size, code);
+
+ /* set the absolute horizontal coords */
+ stuff_p->c[AX] = fermx;
+ stuff_p->c[AW] = fermx - fermwidth / 2;
+ stuff_p->c[AE] = fermx + fermwidth / 2;
+
+ return (YES);
+}
+\f
+/*
+ * Name: trygrid()
+ *
+ * Abstract: Handle a chord STUFF if there are chord grids.
+ *
+ * Returns: YES if a grid will be printed with this chord, NO if not
+ *
+ * Description: If there are to be chord grids printed at the end of the song,
+ * this function sets the "used" flag. If a grid should be
+ * printed here (where the chord is used), it sets the coordinates
+ * of this STUFF appropriately.
+ */
+
+static int
+trygrid(mainll_p, stuff_p)
+
+struct MAINLL *mainll_p; /* MLL struct for this chord stuff */
+struct STUFF *stuff_p; /* the chord stuff */
+
+{
+ int gridswhereused; /* YES or NO for this staff */
+ struct GRID *grid_p; /* point to the grid definition */
+ char *asciichord_p; /* point at ASCII version of chord */
+ float geast, gwest; /* relative coords of the grid */
+ float hstrw; /* half the width of the chord string */
+
+
+ gridswhereused = svpath(mainll_p->u.staff_p->staffno,
+ GRIDSWHEREUSED)->gridswhereused;
+
+ if (Score.gridsatend == NO && gridswhereused == NO) {
+ return (NO);
+ }
+
+ grid_p = findgrid(stuff_p->string);
+
+ /* if grid was never defined, warn and return no grid here */
+ if (grid_p == 0) {
+ asciichord_p = ascii_str(stuff_p->string, YES, NO, TM_CHORD);
+ l_warning(stuff_p->inputfile, stuff_p->inputlineno,
+ "no grid defined for chord %s", asciichord_p);
+ return (NO);
+ }
+
+ if (Score.gridsatend == YES) { /* grids print at end of song*/
+ /* mark grid as used if it hasn't been, and keep count */
+ if (grid_p->used == NO) {
+ grid_p->used = YES;
+ Atend_info.grids_used++;
+ }
+ }
+
+ /* if no grid is to be printed here, get out */
+ if (gridswhereused == NO)
+ return (NO);
+
+ /* we only need east & west here */
+ gridsize(grid_p, stuff_p->all ? 0 : mainll_p->u.staff_p->staffno,
+ (float *)0, (float *)0, &geast, &gwest);
+ hstrw = strwidth(stuff_p->string) / 2.0;
+
+ /*
+ * The stuff extends as far as necessary to contain both the string and
+ * the grid. Unlike for other string stuffs, the string is centered at
+ * this count. (So is the grid, if you ignore any "X fr" string on its
+ * right side.) Note: "til" clauses are not allowed on chords.
+ */
+ stuff_p->c[AE] = stuff_p->c[AX] + MAX(geast, hstrw);
+ stuff_p->c[AW] = stuff_p->c[AX] + MIN(gwest, -hstrw);
+
+ return (YES); /* grid gets printed here */
+}
+\f
+/*
+ * Name: tieslurstuff()
+ *
+ * Abstract: Create STUFF structures for all ties, slurs, and bends.
+ *
+ * Returns: void
+ *
+ * Description: This function puts ST_TIESLUR, ST_TABSLUR, and ST_BEND STUFF
+ * structures in the linked lists. Unlike for the other stuff
+ * types, the parser never does this. So up until now, there have
+ * been none of these in the linked lists. More than one STUFF is
+ * needed if there the tie/slur/bend is across a bar line into
+ * endings, or across a scorefeed.
+ */
+
+static void
+tieslurstuff()
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct GRPSYL *gs_p; /* point at a group */
+ int v; /* voice number, 0 or 1 */
+ int n, k; /* loop variables */
+
+
+ debug(16, "tieslurstuff");
+ initstructs();
+
+ /*
+ * Loop through main linked list, looking for visible STAFFs.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ if (mainll_p->str == S_SSV) {
+ /* keep SSVs up to date for benefit of l_warning */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+ }
+
+ if (mainll_p->str != S_STAFF ||
+ mainll_p->u.staff_p->visible == NO)
+ continue;
+
+ /*
+ * Loop through all voices on this staff.
+ */
+ for (v = 0; v < MAXVOICES && mainll_p->u.staff_p->
+ groups_p[v] != 0; v++) {
+ /*
+ * Loop through the groups in this voice. Ignore rests
+ * and spaces.
+ */
+ for (gs_p = mainll_p->u.staff_p->groups_p[v];
+ gs_p != 0; gs_p = gs_p->next) {
+
+ if (gs_p->grpcont != GC_NOTES)
+ continue;
+
+ /*
+ * For each note in this group, for each tie
+ * and slur starting at it, call a function to
+ * allocate a STUFF for it (more if into an
+ * ending or scorefeed). However, do not do
+ * this for ties on a tablature staff. They
+ * are not to be printed.
+ */
+ for (n = 0; n < gs_p->nnotes; n++) {
+ if (gs_p->notelist[n].tie == YES &&
+ ! is_tab_staff(mainll_p
+ ->u.staff_p->staffno))
+ mktieslurstuff(mainll_p,
+ gs_p, n, -1);
+
+ for (k = 0; k < gs_p->notelist[n].
+ nslurto; k++) {
+ mktieslurstuff(mainll_p,
+ gs_p, n, k);
+ }
+ }
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: mktieslurstuff()
+ *
+ * Abstract: Create STUFF structure(s) for one tie/slur/bend.
+ *
+ * Returns: void
+ *
+ * Description: This function puts ST_TIESLUR, ST_TABSLUR, or ST_BEND STUFF
+ * structure(s) in the linked list for one tie or slur curve.
+ * Normally only one is needed, but if it crosses a scorefeed
+ * two are needed, and if it crosses into a first ending, one is
+ * needed for each following ending.
+ */
+
+static void
+mktieslurstuff(mllstaff_p, gs_p, n, s)
+
+struct MAINLL *mllstaff_p; /* MLL of staff where tie/slur/bend starts */
+struct GRPSYL *gs_p; /* ptr to group where tie/slur/bend starts */
+int n; /* index to note in notelist where it starts */
+int s; /* index into slurtolist, or -1 for tie */
+
+{
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct STAFF *staff_p; /* point at staff of mllstaff */
+ struct MAINLL *mll_p; /* point along MLL */
+ struct MAINLL *mll2_p; /* another pointer along MLL */
+ struct BAR *bar_p; /* point to a bar or pseudobar */
+ struct MAINLL *ebmll_p; /* end bar MLL struct */
+ int endingloc; /* ending location */
+ int stufftype; /* which of the stuff types is it? */
+
+
+ staff_p = mllstaff_p->u.staff_p;
+
+ if (s == -1) { /* tie */
+ stufftype = ST_TIESLUR;
+ } else if (gs_p->notelist[n].is_bend == YES) { /* bend */
+ stufftype = ST_BEND;
+ } else if (is_tab_staff(staff_p->staffno) || /* slur on tab or */
+ is_tab_staff(staff_p->staffno + 1)) { /* tabnote staff */
+ stufftype = ST_TABSLUR;
+ } else { /* slur on other staff*/
+ stufftype = ST_TIESLUR;
+ }
+
+ /* allocate a STUFF structure for this tie/slur/bend */
+ stuff_p = newSTUFF((char *)0, 0, SD_NONE, (double)0, (double)0, 0, 0,
+ (double)0, stufftype, NO, PL_UNKNOWN, (char *)0, 0);
+
+ /* fill in additional items needed for tie/slur */
+ stuff_p->vno = gs_p->vno;
+ stuff_p->beggrp_p = gs_p;
+ stuff_p->begnote_p = &gs_p->notelist[n];
+ stuff_p->curveno = (short)s;
+
+ /* put the new STUFF into this staff's stuff list, at start of list */
+ stuff_p->next = staff_p->stuff_p;
+ staff_p->stuff_p = stuff_p;
+
+ /* if this is not the last group in measure, no more STUFFs needed */
+ if (gs_p->next != 0)
+ return;
+
+ /* if this is a slur to/from nowhere, no second piece needed */
+ if (s >= 0 && (stufftype == ST_TABSLUR || stufftype == ST_TIESLUR) &&
+ IS_NOWHERE(gs_p->notelist[n].slurtolist[s].octave))
+ return;
+
+ /*
+ * We might need more STUFF(s), either because of a scorefeed, or
+ * because of endings. First check for the scorefeed case.
+ */
+ /* find bar line at end of measure */
+ for (ebmll_p = mllstaff_p; ebmll_p != 0 && ebmll_p->str != S_BAR;
+ ebmll_p = ebmll_p->next)
+ ;
+ if (ebmll_p == 0)
+ pfatal("final measure has no bar line");
+
+ /* does a feed occur before next staff? */
+ for (mll_p = ebmll_p; mll_p != 0 && mll_p->str != S_FEED &&
+ mll_p->str != S_STAFF; mll_p = mll_p->next)
+ ;
+ if (mll_p == 0)
+ return;
+
+ if (mll_p->str == S_FEED) {
+ /* found a feed, so try to make the extra STUFF */
+ stuff_p->carryout = YES;
+ mkextrastuff(mll_p, stuff_p, gs_p, n, s, stufftype);
+ }
+
+ /*
+ * Find whether we need to check for endings. This is true when we are
+ * at the start of a first ending. So endingloc has to be STARTITEM,
+ * and the previous bar must not be in an ending. If we are at a FEED,
+ * look at the pseudobar's endingloc, else look at the previous real
+ * bar. In any case, search back from the real bar.
+ */
+ if (mll_p->str == S_FEED) {
+ /*
+ * Find the next CLEFSIG. Normally it's the next thing after
+ * this FEED, but it's possible there are block(s) here and so
+ * it will be after some later FEED.
+ */
+ while (mll_p != 0 && mll_p->str != S_CLEFSIG)
+ mll_p = mll_p->next;
+ if (mll_p == 0)
+ return; /* there must not be any more music */
+ bar_p = mll_p->u.clefsig_p->bar_p;
+ } else {
+ bar_p = ebmll_p->u.bar_p;
+ }
+ if (bar_p->endingloc != STARTITEM)
+ return;
+ for (mll2_p = ebmll_p->prev; mll2_p != 0 && mll2_p->str != S_BAR;
+ mll2_p = mll2_p->prev)
+ ;
+ if (mll2_p != 0 && (mll2_p->u.bar_p->endingloc == STARTITEM ||
+ mll2_p->u.bar_p->endingloc == INITEM))
+ return;
+
+ /*
+ * The curve was into a first ending. So we have to loop forward,
+ * looking for the bar lines at the start of each ending, and try to
+ * make another STUFF for the curve carrying into that ending.
+ */
+ for ( ; mll_p != 0; mll_p = mll_p->next) {
+
+ if (mll_p->str != S_BAR)
+ continue;
+
+ /* see if a pseudo bar occurs before the next staff */
+ for (mll2_p = mll_p; mll2_p != 0 && mll2_p->str != S_STAFF &&
+ (mll2_p->str != S_CLEFSIG ||
+ mll2_p->u.clefsig_p->bar_p == 0);
+ mll2_p = mll2_p->next)
+ ;
+ if (mll2_p == 0 || mll2_p->str == S_STAFF) {
+ /* normal case, no pseudobar */
+ endingloc = mll_p->u.bar_p->endingloc;
+ } else {
+ /* found pseudobar; use it instead of normal bar */
+ endingloc = mll2_p->u.clefsig_p->bar_p->endingloc;
+ }
+
+ switch (endingloc) {
+
+
+ case NOITEM:
+ case ENDITEM:
+ /* out of all endings, we're done */
+ return;
+
+ case STARTITEM:
+ /*
+ * We are at a bar that begins another ending. Try to
+ * find the matching staff in this measure.
+ */
+ mkextrastuff(mll_p, stuff_p, gs_p, n, s, stufftype);
+ }
+ }
+}
+\f
+/*
+ * Name: mkextrastuff()
+ *
+ * Abstract: Create STUFF extra structure(s) for one tie/slur/bend.
+ *
+ * Returns: void
+ *
+ * Description: This function puts ST_TIESLUR, ST_TABSLUR, or ST_BEND STUFF
+ * structure(s) in the linked list for the ending piece of a tie,
+ * slur, or bend that is broken across a scorefeed or into a
+ * second or later ending.
+ */
+
+static void
+mkextrastuff(mll_p, origstuff_p, gs_p, n, s, stufftype)
+
+struct MAINLL *mll_p; /* starts before first staff in measure */
+struct STUFF *origstuff_p; /* original STUFF for this curve */
+struct GRPSYL *gs_p; /* GRPSYL where curve started */
+int n; /* index to note in notelist where it starts */
+int s; /* index into slurtolist, or -1 for tie */
+int stufftype; /* which of the stuff types is it? */
+
+{
+ struct STUFF *stuff_p; /* new stuff */
+ struct GRPSYL *endgs_p; /* group where tie/slur/bend ends */
+ int k; /* loop variable */
+
+
+ /* find first staff */
+ for ( ; mll_p != 0 && mll_p->str != S_STAFF;
+ mll_p = mll_p->next)
+ ;
+
+ /* find matching staff */
+ for ( ; mll_p != 0 && mll_p->str == S_STAFF &&
+ mll_p->u.staff_p->staffno !=
+ gs_p->staffno; mll_p = mll_p->next)
+ ;
+ if (mll_p == 0)
+ pfatal("last bar missing in main linked list [mkextrastuff]");
+ if (mll_p->str != S_STAFF) /* number of staffs changed? */
+ return;
+
+
+ /* allocate a STUFF structure second half of tie/slur/bend */
+ stuff_p = newSTUFF((char *)0, 0, SD_NONE, (double)0, (double)0, 0, 0,
+ (double)0, stufftype, NO, PL_UNKNOWN, (char *)0, 0);
+
+ stuff_p->carryin = YES;
+ stuff_p->costuff_p = origstuff_p;
+
+ /* fill in additional items needed for tie/slur */
+ stuff_p->vno = gs_p->vno;
+ endgs_p = mll_p->u.staff_p->groups_p[gs_p->vno - 1];
+ stuff_p->beggrp_p = endgs_p; /* "beg" is really set to the end here*/
+
+ /* begnote_p must be pointed at the note where tie/slur ends; find it */
+ for (k = 0; k < endgs_p->nnotes; k++) {
+ if (s == -1) {
+ /* tie; check for matching note */
+ if (endgs_p->notelist[k].letter ==
+ gs_p->notelist[n].letter
+ && endgs_p->notelist[k].octave ==
+ gs_p->notelist[n].octave)
+ break;
+ } else {
+ /* slur/bend; check for note we're slurring/bending to*/
+ if (endgs_p->notelist[k].letter ==
+ gs_p->notelist[n].slurtolist[s].letter
+ && endgs_p->notelist[k].octave ==
+ gs_p->notelist[n].slurtolist[s].octave)
+ break;
+ }
+ }
+ if (k == endgs_p->nnotes) {
+ l_warning(endgs_p->inputfile, endgs_p->inputlineno,
+ "can't find note being tied, slurred, or bent to");
+ FREE(stuff_p);
+ return;
+ }
+
+ stuff_p->begnote_p = &endgs_p->notelist[k]; /* end of tie/slur */
+ stuff_p->curveno = (short)s; /* same as for the carryout stuff */
+
+ /* put the new STUFF into this staff's stuff list, at start of list */
+ stuff_p->next = mll_p->u.staff_p->stuff_p;
+ mll_p->u.staff_p->stuff_p = stuff_p;
+}
~mdw / mup / blobdiff