--- /dev/null
+
+/* Copyright (c) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by Arkkra Enterprises */
+/* All rights reserved */
+
+/* functions for checking for various classes of errors such as
+ * values out of range, or trying to do something in an illegal context.
+ * Also contains the code to combine multiple measures of rests into
+ * multirests. */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+
+static struct MAINLL *add_pre_meas P((struct MAINLL *insert_p, int start,
+ int end, int add_bar));
+static int check_all_rests P((struct STAFF *staff_p, int count));
+static void do_combine P((struct MAINLL *begin_p, struct MAINLL *end_p,
+ int nummeas, int min_combine));
+static int valid_mark_item P((int mark, int place));
+static void mv_accs P((struct MAINLL *mll_p));
+static void move_xoct P((struct STUFF *stuff_p, struct MAINLL *newfirst_p,
+ int staffno, int bars, int start));
+static void addped P((struct STUFF *pedal_p, struct MAINLL *mll_p));
+
+
+\f
+
+/* give error message if given number is not within specified range. */
+/* return NO if out of range, YES if okay */
+
+/* once upon a time, there was the rangecheck function, and it got called
+ * many times. Then midi support was added and that code needed to do lots
+ * of rangechecks, but with the filename and line number something other
+ * than Curr_filename, and yylineno, so the l_rangecheck function was
+ * created, and rangecheck just calls that. There isn't an l_frangecheck
+ * to go with frangecheck, because nothing needed it. Another case where
+ * C++ would have been nice, so we could default added arguments....
+ */
+
+int
+rangecheck(n, min, max, name)
+
+int n; /* the number to check */
+int min; /* has to be at least this big */
+int max; /* can be no bigger than this */
+char *name; /* describes what n represents, to use in error message */
+
+{
+ return(l_rangecheck(n, min, max, name, Curr_filename, yylineno));
+}
+
+int
+l_rangecheck(n, min, max, name, fname, lineno)
+
+int n; /* the number to check */
+int min; /* has to be at least this big */
+int max; /* can be no bigger than this */
+char *name; /* describes what n represents, to use in error message */
+char *fname; /* file name */
+int lineno; /* line number */
+
+{
+ if ( (n < min) || (n > max) ) {
+ l_yyerror(fname, lineno,
+ "%s (%d) is out of range (must be between %d and %d)",
+ name, n, min, max);
+ return(NO);
+ }
+ return(YES);
+}
+
+
+/* This function is rather like rangecheck, except it also allows a special
+ * "empty" value. */
+
+int
+erangecheck(n, min, max, empty_value, name)
+
+int n; /* the number to check */
+int min; /* has to be at least this big */
+int max; /* can be no bigger than this */
+int empty_value; /* this is also a legal value */
+char *name; /* describes what n represents, to use in error message */
+
+{
+ if (n == empty_value) {
+ /* value is okay--means user set to empty */
+ return(YES);
+ }
+ if ( (n < min) || (n > max) ) {
+ l_yyerror(Curr_filename, yylineno,
+ "%s (%d) out of range (must be between %d to %d or set to nothing at all)",
+ name, n, min, max);
+ return(NO);
+ }
+ return(YES);
+}
+\f
+
+/* just like rangecheck except for a float instead of int */
+
+int
+frangecheck(n, min, max, name)
+
+float n; /* the number to check */
+float min; /* has to be at least this big */
+float max; /* can be no bigger than this */
+char *name; /* describes what n represents, to use in error message */
+
+{
+ if ( (n < min) || (n > max) ) {
+ l_yyerror(Curr_filename, yylineno,
+ "%s (%.3f) is out of range (must be between %.3f and %.3f)",
+ name, n, min, max);
+ return(NO);
+ }
+ return(YES);
+}
+\f
+
+/* give error and return NO if given number is not a power of 2 */
+
+int
+power_of2check(n, name)
+
+int n; /* number to verify */
+char *name; /* what n represents, for error message */
+
+{
+ if ( (n <= 0) || ((n & (n - 1)) != 0)) {
+ l_yyerror(Curr_filename, yylineno,
+ "%s (%d) not a power of 2", name, n);
+ return(NO);
+ }
+ return(YES);
+}
+\f
+
+/* check that current action is valid in current context. */
+/* If so, return YES, otherwise print message and return NO */
+
+int
+contextcheck(validcontext, action)
+
+int validcontext; /* bitmap of valid contexts */
+char *action; /* what action is to be done, for error messages */
+
+{
+ static int shouldBmusic; /* count of how many consecutive times
+ * we were called when we should have been
+ * in music context, but weren't
+ */
+
+ /* Forgetting to say 'music' can cause tons of errors,
+ * which may confuse the user. So try to deduce what they meant.
+ */
+ if (validcontext == C_MUSIC) {
+ if (Context != C_MUSIC) {
+ if (++shouldBmusic > 5) {
+
+ l_yyerror(Curr_filename, yylineno, "guessing you forgot to specify 'music'; changing to music context to try to recover");
+ Context = C_MUSIC;
+ }
+ }
+ else {
+ shouldBmusic = 0;
+ }
+ }
+ else {
+ shouldBmusic = 0;
+ }
+
+ if ((validcontext & Context) == 0) {
+ l_yyerror(Curr_filename, yylineno, "%s not valid in %s context",
+ action, contextname(Context));
+ return(NO);
+ }
+ return(YES);
+}
+\f
+
+/* convert context number back to name */
+
+char *
+contextname(cont)
+
+int cont; /* context number */
+
+{
+ switch(cont) {
+ case C_MUSIC:
+ return("music");
+ case C_SCORE:
+ return("score");
+ case C_STAFF:
+ return("staff");
+ case C_VOICE:
+ return("voice");
+ case C_HEADER:
+ return("header");
+ case C_FOOTER:
+ return("footer");
+ case C_HEAD2:
+ return("header2");
+ case C_FOOT2:
+ return("footer2");
+ case C_TOP:
+ return("top");
+ case C_TOP2:
+ return("top2");
+ case C_BOT:
+ return("bottom");
+ case C_BOT2:
+ return("bottom2");
+ case C_BLOCK:
+ return("block");
+ default:
+ return("unknown");
+ }
+}
+\f
+
+/* check that at least one staff is visible, print error message if not */
+
+void
+check_at_least1visible()
+
+{
+ int staffno;
+
+ /* go through list of staffs, if we find a visible one, fine */
+ for (staffno = Score.staffs; staffno > 0; staffno--) {
+ if ( (svpath(staffno, VISIBLE))->visible == YES) {
+ return;
+ }
+ }
+
+ yyerror("no staffs visible");
+ return;
+}
+\f
+
+/* if there is a change in visibility status, need to have a scorefeed after
+ * that. So go through main list. If there is a change in visibility, or
+ * in number of staffs, or stafflines, or staffscale, go
+ * backwards in list till hit FEED, BAR, or beginning of list. If hit FEED
+ * first, throw it away. Then search forward from the SSV until we hit
+ * FEED or STAFF. If FEED, fine. If STAFF, insert
+ * a FEED. If we discarded the user FEED because it was in the wrong place,
+ * mark the pagefeed field as they had it.
+ * This function also adds a measure of space to the beginning of the song
+ * if we are doing MIDI. If a song begins with a grace note,
+ * we want to move that back into the "previous" measure, so this will
+ * create that measure. It's easier to deal with that here, before
+ * makechords() is called, than to try to add it in later.
+ */
+
+void
+chk_vis_feed()
+
+{
+ struct MAINLL *mll_p, *m_p; /* to walk through main list */
+ struct MAINLL *new_feed_p;
+ short set_pagefeed = NO; /* if to set pagefeed field */
+ short s; /* staff index */
+ short vis[MAXSTAFFS + 1]; /* which staffs are currently visible */
+ short stlines[MAXSTAFFS + 1]; /* stafflines for each staff */
+ float stscale[MAXSTAFFS + 1]; /* staffscale for each staff */
+ short num_staffs; /* number of staffs */
+ short add_extra; /* if to add extra space measure */
+
+
+ debug(4, "chk_vis_feed");
+
+ /* If doing MIDI, we want to add an extra space measure to the
+ * beginning */
+ add_extra = Doing_MIDI;
+
+ /* go through main list looking for visibility changes */
+ initstructs();
+ for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
+ mll_p = mll_p->next) {
+
+ if (mll_p->str == S_SSV) {
+ /* SSV can only follow a BAR or BLOCKHEAD or another
+ * SSV. If it follows a LINE/CURVE/PRHEAD,
+ * then user must have entered music context,
+ * but not entered any music,
+ * just line/curve/print things. This violates our
+ * mainlist rules, so we have to disallow */
+ if (mll_p->prev != 0 && mll_p->prev->str != S_BAR &&
+ mll_p->prev->str != S_BLOCKHEAD &&
+ mll_p->prev->str != S_SSV) {
+ l_yyerror(mll_p->inputfile, mll_p->inputlineno,
+ "music context containing only lines/curves/print statements is not allowed");
+ }
+
+ /* Only want to insert a FEED if there truly was
+ * a change in the number of staffs to be printed.
+ * User may have set visible when it was already set,
+ * or just changed voice visibility which didn't
+ * cause the visibily of staffs to change, or
+ * something like that, which doesn't count.
+ * So see what visiblity, stafflines,
+ * and staffscale are set to now,
+ * then assign the SSV and see if things changed.
+ */
+ for (s = 1; s <= MAXSTAFFS; s++) {
+ /* save current values of interest */
+ vis[s] = svpath(s, VISIBLE)->visible;
+ stlines[s] = svpath(s, STAFFLINES)->stafflines;
+ stscale[s] = svpath(s, STAFFSCALE)->staffscale;
+ }
+ num_staffs = Score.staffs;
+
+ /* make any updates */
+ asgnssv(mll_p->u.ssv_p);
+
+ /* now compare with previous values */
+ for (s = 1; s <= MAXSTAFFS; s++) {
+ if (vis[s] != svpath(s, VISIBLE)->visible ||
+ stlines[s] != svpath(s,
+ STAFFLINES)->stafflines ||
+ stscale[s] != svpath(s,
+ STAFFSCALE)->staffscale) {
+ /* something changed */
+ break;
+ }
+ }
+
+ if (s <= MAXSTAFFS || Score.staffs != num_staffs) {
+
+ /* found a change. Go backwards. If find a
+ * FEED, discard it. Otherwise ok */
+ for (m_p = mll_p->prev;
+ m_p != (struct MAINLL *) 0;
+ m_p = m_p->prev) {
+
+ if (IS_CLEFSIG_FEED(m_p)) {
+ /* feed in wrong place. Discard
+ * this one. We'll put one in
+ * the proper place later */
+ set_pagefeed =
+ m_p->u.feed_p->pagefeed;
+ unlinkMAINLL(m_p);
+ FREE(m_p);
+ break;
+ }
+
+ else if (m_p->str == S_BAR) {
+ break;
+ }
+ }
+
+ /* now look forwards. If find FEED, fine.
+ * If not, insert one */
+ for (m_p = mll_p->next;
+ m_p != (struct MAINLL *) 0;
+ m_p = m_p->next) {
+
+ if (m_p->str == S_FEED) {
+ /* user already put one in */
+ break;
+ }
+
+ else if (m_p->str == S_STAFF) {
+ /* user neglected to put in an
+ * explicit feed, so we add
+ * one for them */
+ new_feed_p =
+ newMAINLLstruct(S_FEED,
+ -1);
+ new_feed_p->u.feed_p->pagefeed
+ = set_pagefeed;
+ insertMAINLL(new_feed_p,
+ m_p->prev);
+ break;
+ }
+ }
+ set_pagefeed = NO;
+ }
+ }
+
+ else if (add_extra == YES && mll_p->str == S_STAFF) {
+ /* For MIDI purposes, add a measure space to the
+ * beginning of the song, in case we need to move
+ * grace notes back into it. Strictly speaking,
+ * we probably don't need to do this unless there
+ * truly is a grace note at the beginning, but
+ * it should never hurt to add it, and it doesn't
+ * seem worth the effort to check. */
+ add_pre_meas(mll_p->prev, 1, Score.staffs, YES);
+
+ add_extra = NO;
+ }
+ }
+}
+\f
+
+/* For MIDI, we add a measure of space preceeding what the user put in.
+ * This is used in case they start the piece with grace notes that we need
+ * to move back in the preceeding measure, since this guarantees there will
+ * be a preceeding measure. Also, for when taking a "slice" of the piece,
+ * skipping measures at the beginning, this is where we attach any MIDI
+ * STUFFs that happened during the skipped part.
+ * Returns the last MAINLL added.
+ */
+
+static struct MAINLL *
+add_pre_meas(insert_p, start, end, add_bar)
+
+struct MAINLL *insert_p; /* insert after here */
+int start; /* staff number of first STAFF to create */
+int end; /* staff number of last STAFF to create */
+int add_bar; /* if YES, add an invisible bar too */
+
+{
+ int staff; /* loop through staffs to be created */
+ struct MAINLL *new_p; /* new STAFFs */
+ int numvoices; /* number of voices on current staff */
+ int v; /* voice index */
+
+ /* Create a staff with measure space for all
+ * defined staffs/voices, and link onto main list */
+ for (staff = start; staff <= end; staff++) {
+
+ /* create the STAFF struct itself */
+ new_p = newMAINLLstruct(S_STAFF, -1);
+ new_p->u.staff_p->staffno = staff;
+ new_p->u.staff_p->visible = svpath(staff, VISIBLE)->visible;
+
+ numvoices = vscheme_voices(svpath(staff, VSCHEME)->vscheme);
+ for (v = 0; v < numvoices; v++) {
+ add_meas_space( &(new_p->u.staff_p->groups_p[v]),
+ staff, v + 1);
+ }
+
+ /* link onto main list, and arrange to
+ * link the next thing after this one */
+ insertMAINLL(new_p, insert_p);
+ insert_p = new_p;
+ }
+ if (add_bar == YES) {
+ /* add an invisible bar line */
+ new_p = newMAINLLstruct(S_BAR, -1);
+ new_p->u.bar_p->bartype = INVISBAR;
+ insertMAINLL(new_p, insert_p);
+ insert_p = new_p;
+ }
+ return(insert_p);
+}
+\f
+
+/* check for valid interval. Unison, octave, fourths and fifths can not be
+ * major or minor. The others cannot be perfect. */
+
+void
+chk_interval(inttype, intnum)
+
+int inttype; /* PERFECT, MINOR, etc */
+int intnum; /* e.g., 4 for fourth */
+
+{
+ if (intnum <= 0) {
+ yyerror("transposition interval must be > 0");
+ return;
+ }
+
+ /* collapse into 1 octave. It's okay that a 7th will come out zero
+ * because of the way things are checked below. */
+ intnum %= 7;
+
+ switch (inttype) {
+
+ case PERFECT:
+ switch (intnum) {
+ case 1:
+ case 4:
+ case 5:
+ break;
+ default:
+ yyerror("specified interval cannot be perfect");
+ break;
+ }
+ break;
+
+ case MAJOR:
+ case MINOR:
+ switch(intnum) {
+ case 1:
+ case 4:
+ case 5:
+ yyerror("specified interval cannot be major or minor");
+ break;
+ default:
+ break;
+ }
+ break;
+
+ default:
+ /* everything else is okay */
+ break;
+ }
+}
+\f
+
+/* if specified used[] field is set to YES, print warning that its value is
+ * being overridden. This is to let user know they set the same parameter
+ * twice in the same SSV context */
+
+void
+used_check(mll_p, var, name)
+
+struct MAINLL *mll_p; /* check used[] in the SSV pointed to by this */
+int var; /* check this index in the used[] array */
+char *name; /* name of variable, for warning message */
+
+{
+ if (mll_p == (struct MAINLL *) 0) {
+ l_yyerror(Curr_filename, yylineno,
+ "can't set %s in %s context", name, contextname(Context));
+ return;
+ }
+
+ if (mll_p->str != S_SSV) {
+ pfatal("bad argument passed to used_check()");
+ }
+
+ if (mll_p->u.ssv_p->used[var] == YES) {
+ l_warning(Curr_filename, yylineno,
+ "setting of '%s' parameter overrides previous setting",
+ name);
+ }
+}
+\f
+
+/* go through list and combine multiple consecutive rests into multi-rests */
+
+void
+combine_rests(c)
+
+int c; /* argument to -c command line option;
+ * only combine when there are at least
+ * this many rest measures in a row.
+ * Set to NORESTCOMBINE if user didn't use -c option. */
+
+{
+ struct MAINLL *mll_p; /* walk through main list */
+ struct MAINLL *begin_p = (struct MAINLL *) 0; /* where section to
+ * combine begins */
+ struct MAINLL *end_p = (struct MAINLL *) 0;
+ int all_rests = YES;
+ int n; /* how many measures minimum to combine */
+ int count = 0; /* how many measures of all rests */
+ int begin_valid = NO; /* if begin_p has been set. Can't just check to
+ * see if it is null, because null is valid */
+ struct SSV *ssv_p;
+ char *timerep; /* current time signature representation */
+
+
+ debug(2, "combine_rests");
+
+ /* go through main list */
+ initstructs();
+ n = c; /* init to value of -c option */
+ for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
+ mll_p = mll_p->next) {
+
+ if (Doing_MIDI == YES && mll_p == Mainllhc_p) {
+ /* Don't want to combine the "extra" measure
+ * we added in for MIDI, so skip it. */
+ for ( ; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ mll_p = mll_p->next;
+ break;
+ }
+ }
+ if (mll_p == 0) {
+ /* Must be no valid music data in the file.
+ * check4barline_at_end() should have already
+ * reported this to user, so we can just
+ * return silently here. */
+ return;
+ }
+ }
+
+ /* for each STAFF that is visible, see if it is all rests */
+ if (mll_p->str == S_STAFF) {
+ /* remember where we are, in case this is the beginning
+ * of section that needs to be combined */
+ if (begin_valid == NO) {
+ begin_p = mll_p->prev;
+ begin_valid = YES;
+ }
+
+ /* if we have all rests so far, check this staff */
+ if (all_rests == YES) {
+ if ((all_rests = check_all_rests
+ (mll_p->u.staff_p, count))
+ == NO) {
+ /* this measure was not all rests.
+ * Check to see if before that we
+ * had seen a run of
+ * all rests. If so, combine them */
+ do_combine(begin_p, end_p, count, n);
+ }
+ }
+ }
+
+ else if (mll_p->str == S_BAR) {
+ if (all_rests == YES) {
+ /* this measure was all rests, so
+ * bump counter */
+ if (mll_p->u.bar_p->bartype != INVISBAR) {
+ count++;
+ }
+ end_p = mll_p;
+ /* if not an ordinary bar, end the combining */
+ if ( (mll_p->u.bar_p->reh_type != REH_NONE) ||
+ (mll_p->u.bar_p->endingloc
+ != NOITEM &&
+ mll_p->u.bar_p->endingloc
+ != INITEM) ||
+ ( (mll_p->u.bar_p->bartype
+ != SINGLEBAR) &&
+ (mll_p->u.bar_p->bartype !=
+ INVISBAR) ) ) {
+ if (mll_p->u.bar_p->bartype == RESTART) {
+ /* There is an empty "measure"
+ * of space before restarts */
+ count--;
+ /* need to end combining at
+ * the previous bar line */
+ if (count >= n) {
+ for (end_p = end_p->prev;
+ end_p != 0 &&
+ end_p->str != S_BAR;
+ end_p = end_p->prev) {
+ ;
+ }
+ }
+ }
+
+ do_combine(begin_p, end_p, count, n);
+
+ /* re-initialize */
+ count = 0;
+ begin_p = (struct MAINLL *) 0;
+ all_rests = YES;
+ begin_valid = NO;
+ }
+ }
+ else {
+ /* re-init for next measure */
+ all_rests = YES;
+ count = 0;
+ begin_p = (struct MAINLL *) 0;
+ begin_valid = NO;
+ }
+ }
+
+ else if (mll_p->str == S_SSV) {
+
+ ssv_p = mll_p->u.ssv_p;
+
+ /* If -c option was not used, we use the value of
+ * the restcombine parameter. */
+ if (c == NORESTCOMBINE &&
+ ssv_p->used[RESTCOMBINE] == YES) {
+ n = ssv_p->restcombine;
+ }
+
+ /* if there is a change in visibility or a relevant
+ * change on an already-visible score,
+ * that is grounds to end the combination */
+ if ( ssv_p->used[VISIBLE] == YES ||
+ ((((mll_p->u.ssv_p->staffno == 0) ||
+ (svpath(mll_p->u.ssv_p->staffno,
+ VISIBLE))->visible == YES)) &&
+ (ssv_p->used[CLEF] == YES
+ || ssv_p->used[SHARPS] == YES
+ || ssv_p->used[TIME] == YES
+ || ssv_p->used[TRANSPOSITION] == YES
+ || ssv_p->used[ADDTRANSPOSITION] == YES
+ || ssv_p->used[VISIBLE] == YES))) {
+ do_combine(begin_p, end_p, count, n);
+
+ /* re-initialize */
+ count = 0;
+ begin_p = (struct MAINLL *) 0;
+ all_rests = YES;
+ begin_valid = NO;
+ }
+
+ /* keep track of visibility */
+ asgnssv(mll_p->u.ssv_p);
+ }
+ else if (mll_p->str == S_FEED) {
+ do_combine(begin_p, end_p, count, n);
+ count = 0;
+ begin_p = (struct MAINLL *) 0;
+ all_rests = YES;
+ begin_valid = NO;
+ }
+ }
+
+ /* do final combination if any */
+ do_combine(begin_p, end_p, count, n);
+
+ /* If there were case of TS_ALWAYS with alternating time
+ * signatures, we had to save the entire time signature list for
+ * every measure in case it turned out to be a multirest.
+ * Now we can shorten down to one for those that aren't,
+ * and need to do this so later code works.
+ */
+ initstructs();
+ timerep = 0;
+ for (mll_p = Mainllhc_p; mll_p != 0; mll_p = mll_p->next) {
+ struct MAINLL * nmll_p;
+
+ if (mll_p->str != S_SSV) {
+ continue;
+ }
+ asgnssv(mll_p->u.ssv_p);
+ if (Score.timevis != PTS_ALWAYS) {
+ continue;
+ }
+
+ /* If we need to change the current timerep,
+ * need to do the permanent copy in the main list,
+ * not the one current in Score, so save pointer to current
+ * one in main list. */
+ if (mll_p->u.ssv_p->used[TIME]) {
+ timerep = mll_p->u.ssv_p->timerep;
+ }
+
+ for (nmll_p = mll_p->next; nmll_p != 0;
+ nmll_p = nmll_p->next) {
+ if (nmll_p->str == S_STAFF) {
+ if (nmll_p->u.staff_p->groups_p[0]->basictime >= -1) {
+ /* not followed by multi-rest,
+ * can truncate time sig */
+ char * t;
+ for (t = timerep; t != 0 && *t != 0; t++) {
+ if (*t == TSR_ALTERNATING) {
+ *t = TSR_END;
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+}
+\f
+
+/* given a STAFF, return NO if the staff is visible and has at least one
+ * voice which contains notes, or has lyrics or STUFF (except if stuff is on
+ * or before the first beat of the first measure. Otherwise return YES */
+
+static int
+check_all_rests(staff_p, count)
+
+struct STAFF *staff_p; /* which staff info to check */
+int count; /* how many measures of all rest so far */
+
+{
+ int v; /* index through voices */
+ struct GRPSYL *gs_p; /* walk through grpsyl list */
+ struct STUFF *stuff_p; /* walk through stuff list */
+
+
+ /* if not visible, then okay to treat as all rests */
+ if ( (svpath(staff_p->staffno, VISIBLE))->visible == NO) {
+ return(YES);
+ }
+
+ /* if has lyrics, consider that not rests */
+ if (staff_p->nsyllists > 0) {
+ return(NO);
+ }
+
+ /* having STUFF is usually grounds for not being treated as all rests */
+ /***** what to do about earlier stuff that happens to spill into
+ *** this measure???????? *****/
+ if (staff_p->stuff_p != (struct STUFF *) 0) {
+ /* special case. If this is the first measure of rests, and
+ * all STUFFs occur on or before beat 1 and have no til clause,
+ * then that's okay.
+ * This allows user to change tempo or something similar at
+ * the beginning of a combined multirest. */
+ if (count > 0) {
+ /* Combining only applies to printing, not MIDI,
+ * so MIDI STUFFs can be ignored */
+ for (stuff_p = staff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->stuff_type != ST_MIDI) {
+ return(NO);
+ }
+ }
+ /* all the STUFFs must have been MIDI */
+ return(YES);
+ }
+ for (stuff_p = staff_p->stuff_p; stuff_p != (struct STUFF *) 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->stuff_type == ST_MIDI) {
+ continue;
+ }
+ if (stuff_p->start.count > 1.0 || stuff_p->end.bars > 0
+ || stuff_p->end.count > 0.0) {
+ return(NO);
+ }
+ }
+ }
+
+ for (v = 0; v < MAXVOICES; v++) {
+ for (gs_p = staff_p->groups_p[v]; gs_p != (struct GRPSYL *) 0;
+ gs_p = gs_p->next) {
+ /* if voice is invisible, treat like all rests */
+ if (vvpath(staff_p->staffno, v + 1, VISIBLE)->visible == NO) {
+ continue;
+ }
+
+ if (gs_p->grpcont == GC_NOTES) {
+ return(NO);
+ }
+
+ else if (gs_p->is_meas == NO) {
+ /* We only combine mr and ms. If user entered
+ * one or more rests/spaces that fill the
+ * entire measure, we don't combine,
+ * because the user may have had some reason
+ * for explicitly specifying time values rather
+ * than using a measure duration. */
+ return(NO);
+ }
+ else if (gs_p->basictime < -1) {
+ /* already multirest! */
+ return(NO);
+ }
+ }
+ }
+ return(YES);
+}
+\f
+
+/* effect the combination of several measures of rests into a multirest. */
+
+static void
+do_combine(begin_p, end_p, nummeas, min_combine)
+
+struct MAINLL *begin_p; /* start combining from here */
+struct MAINLL *end_p; /* stop here */
+int nummeas; /* hom many measures are being combined */
+int min_combine; /* minimum number to combine, or NORESTCOMBINE */
+
+{
+ struct MAINLL *new_p;
+ struct MAINLL *old_p; /* first of items to discard */
+ struct GRPSYL *gs_p; /* for multirest */
+ struct MAINLL *mll_p; /* to find staff for transferring stuffs */
+ short s; /* index through staffs */
+ short numvoices;
+
+
+ if (min_combine == NORESTCOMBINE || nummeas < min_combine) {
+ /* don't bother to combine */
+ return;
+ }
+
+ /* discard everything in main list between the given points.
+ * It will be either STAFFs with all rests to be replaced or
+ * BARs to be discarded, or things associated with invisible staffs.
+ * I guess maybe we should free up the space rather than merely
+ * unhitching it from the list, but it hardly seems worth the bother,
+ * especially since we'd have to be careful not to delete the STUFFs
+ * on the first one in case they were needed at the end of this
+ * function.
+ */
+ if (begin_p == (struct MAINLL *) 0) {
+ old_p = Mainllhc_p;
+ Mainllhc_p = end_p;
+ }
+ else {
+ old_p = begin_p->next;
+ begin_p->next = end_p;
+ }
+ if (end_p != (struct MAINLL *) 0) {
+ end_p->prev = begin_p;
+ }
+
+ /* add multirest to list */
+ for (s = Score.staffs; s > 0; s--) {
+ new_p = newMAINLLstruct(S_STAFF, -1);
+ gs_p = newGRPSYL(GS_GROUP);
+ gs_p->grpcont = GC_REST;
+ gs_p->basictime = -nummeas;
+ gs_p->fulltime = Score.time;
+ gs_p->staffno = s;
+ gs_p->vno = 1;
+
+ new_p->u.staff_p->groups_p[0] = gs_p;
+ numvoices = vscheme_voices(svpath(s, VSCHEME)->vscheme);
+ if (numvoices > 1) {
+ add_meas_space( &(new_p->u.staff_p->groups_p[1]), s, 2);
+ new_p->u.staff_p->groups_p[1]->basictime = -nummeas;
+ /* if the first voice was invisible,
+ * but the second voice is visible, need to convert
+ * the space just created into a rest. */
+ if (vvpath(s, 1, VISIBLE)->visible == NO &&
+ vvpath(s, 2, VISIBLE)->visible == YES) {
+ new_p->u.staff_p->groups_p[1]->grpcont = GC_REST;
+ }
+ }
+ if (numvoices > 2) {
+ add_meas_space( &(new_p->u.staff_p->groups_p[2]), s, 3);
+ new_p->u.staff_p->groups_p[2]->basictime = -nummeas;
+ /* if only the third voice is visible, need to convert
+ * the space just created into a rest. */
+ if (vvpath(s, 1, VISIBLE)->visible == NO &&
+ vvpath(s, 2, VISIBLE)->visible == NO &&
+ vvpath(s, 3, VISIBLE)->visible == YES) {
+ new_p->u.staff_p->groups_p[2]->grpcont = GC_REST;
+ }
+ }
+ new_p->u.staff_p->staffno = s;
+ new_p->u.staff_p->visible = svpath(s, VISIBLE)->visible;
+ insertMAINLL(new_p, begin_p);
+
+ /* if there were any STUFFs on or before the first beat of the
+ * first measure, we have to transfer them to the stufflist of
+ * the multirest. We can transfer the entire list, because if
+ * there were any items that shouldn't be transferred, we
+ * wouldn't have allowed the multirest combination in the
+ * first place. */
+ for (mll_p = old_p; mll_p != (struct MAINLL *) 0
+ && mll_p != end_p; mll_p = mll_p->next) {
+ if (mll_p->str == S_STAFF
+ && mll_p->u.staff_p->staffno == s) {
+ new_p->u.staff_p->stuff_p =
+ mll_p->u.staff_p->stuff_p;
+ break;
+ }
+ }
+ }
+}
+\f
+
+/* translate MK_* to printable name */
+
+char *
+markname(mark)
+
+int mark; /* MK_* value */
+
+{
+ switch(mark) {
+ case MK_MUSSYM:
+ return("mussym");
+ case MK_OCTAVE:
+ return("octave");
+ case MK_DYN:
+ return("dyn");
+ case MK_OTHERTEXT:
+ return("othertext");
+ case MK_CHORD:
+ return("chord");
+ case MK_LYRICS:
+ return("lyrics");
+ case MK_ENDING:
+ return("ending");
+ case MK_REHEARSAL:
+ return("rehearsal");
+ case MK_PEDAL:
+ return("pedal");
+ default:
+ pfatal("markname(): missing case");
+ /*NOTREACHED*/
+ return("");
+ }
+}
+\f
+
+/* verify that a mark order list is valid */
+
+void
+chk_order(ssv_p, place)
+
+struct SSV *ssv_p; /* check the markorder list in here */
+int place; /* PL_*, which list to check */
+
+{
+ int m, n; /* index through MK_* */
+ int level; /* value in markorder table */
+
+ for (m = 0; m < NUM_MARK; m++) {
+ if (ssv_p->markorder[place][m] == 0) {
+ /* no level set for this mark, so skip it */
+ continue;
+ }
+
+ /* some mark types cannot be equal with any other types */
+ switch (m) {
+
+ case MK_LYRICS:
+ case MK_ENDING:
+ case MK_REHEARSAL:
+ case MK_PEDAL:
+ level = ssv_p->markorder[place][m];
+ for (n = 0; n < NUM_MARK; n++) {
+ if (n == m) {
+ continue;
+ }
+ if (ssv_p->markorder[place][n] == level) {
+ l_yyerror(Curr_filename, yylineno,
+ "%s cannot be at same level as %s",
+ markname(m), markname(n));
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if (valid_mark_item(m, place) == NO) {
+ char *placename;
+ switch (place) {
+ case PL_ABOVE:
+ placename = "above";
+ break;
+ case PL_BELOW:
+ placename = "below";
+ break;
+ case PL_BETWEEN:
+ placename = "between";
+ break;
+ default:
+ pfatal("chk_order: invalid place %d", place);
+ /* not reached; it just avoids bogus
+ * "used before set" warning */
+ placename = "";
+ }
+ l_warning(Curr_filename, yylineno,
+ "%s not valid in %sorder list",
+ markname(m), placename);
+ }
+ }
+}
+\f
+
+/* return YES if MK_* item is valid at given place, NO if not */
+
+static int
+valid_mark_item(mark, place)
+
+int mark; /* MK_* */
+int place; /* PL_* */
+
+{
+ if (mark == MK_OCTAVE && place == PL_BETWEEN) {
+ return(NO);
+ }
+ if ((mark == MK_ENDING || mark == MK_REHEARSAL)
+ && place != PL_ABOVE) {
+ return(NO);
+ }
+ if (mark == MK_PEDAL && place != PL_BELOW) {
+ return(NO);
+ }
+
+ /* everything else is okay */
+ return(YES);
+}
+\f
+
+/*
+ * User can specify that only a portion of the song is to be processed.
+ * This is done via one or two numbers, the first measure to include and
+ * the last.
+ * Positive numbers are relative to the beginning of the song, negative
+ * are relative to the end. So, as examples:
+ * 1 // the whole song (default)
+ * 1,-1 // another way to say the whole song
+ * 5 // start at measure 5, through the end
+ * 6,7 // only measures 6 and 7
+ * 1,10 // measures 1 through 10
+ * 1,-8 // skip the last 7 measures
+ * -12,-3 // only process from 12 measures from the end through
+ * // the third from the end
+ *
+ * When counting measures for this, invisbar bars do not count.
+ * It is measured by the number of bars encountered in input, not in
+ * performance: the bars are not double counted in sections
+ * between repeat signs.
+ *
+ * A value of zero is not allowed.
+ * A positive start larger than the number of measures in the song
+ * is a user error.
+ * A negative start that would result in starting before the beginning
+ * starts at the beginning (with a warning)
+ * A positive end larger than the number of measures in the song goes to
+ * end of song (with a warning)
+ * An end value that would result in starting before the beginning of the
+ * song or before the start value is a user error.
+ *
+ * Only one slice is supported. I.e., you can't ask for something
+ * like measures 4-10, 17-24, and 46-80.
+ * You can only ask for one of those ranges.
+ * (You could get that effect by making 3 files and playing them one after
+ * another, although there might be slight pauses in between.)
+ *
+ * A possible future enhancement might be
+ * to also be able to specify by rehearsal mark.
+ * If a rehearsal mark string is specified rather than a number,
+ * the rehearsal mark having that string (ASCII-ized by removing font, size,
+ * and other special things) would be used as the marked place. In this case,
+ * the end place would be only up to the rehearsal mark, not through the
+ * measure that starts there.
+ */
+
+void
+chk_x_arg(x_arg, start_p, end_p)
+
+char *x_arg; /* arg to -x option specified by user */
+int *start_p; /* start gets returned here */
+int *end_p; /* end gets returned here */
+
+{
+ char *arg_p; /* pointer to where end starts in x_arg */
+
+ /* set to defaults */
+ *start_p = 1;
+ *end_p = -1;
+
+ if (x_arg == 0 || *x_arg == '\0') {
+ /* No -x option, use whole song as normal */
+ return;
+ }
+
+ *start_p = (int) strtol(x_arg, &arg_p, 0);
+ if (arg_p == x_arg) {
+ if (Mupmate == YES) {
+ l_yyerror(0, -1, "Run > Set Options > Extract Measures: value must be one or two numbers.");
+ }
+ else {
+ l_yyerror(0, -1, "argument for %cx option must be one or two numbers", Optch);
+ }
+ }
+
+ /* If there is a comma, get the "end" argument as well */
+ if (*arg_p == ',') {
+ *end_p = (int) strtol(arg_p + 1, &arg_p, 0);
+ }
+
+ /* We should be at end of string, either after first arg if there
+ * was only one arg, or after second if there were two. */
+ if (*arg_p != '\0') {
+ if (Mupmate == YES) {
+ l_yyerror(0, -1, "Run > Set Options > Extract Measures: value must be one or two numbers.");
+ }
+ else {
+ l_yyerror(0, -1, "argument for %cx option must be one or two numbers", Optch);
+ }
+ }
+}
+\f
+
+/* This function does the slicing to extract selected measures from the input */
+
+void
+extract(start, end)
+
+int start; /* Start at this measure number. A negative
+ * number means count from the end of the piece,
+ * so -3 would mean the last 3 bars. */
+int end; /* Play only through this measure number.
+ * Negative is relative to the end of the piece. */
+
+{
+ int pickup; /* YES if song begins
+ * with pickup measure */
+ int numbars; /* total number of bars */
+ int bars; /* how many processed so far */
+ int mrbars; /* how many bars of multirest */
+ struct MAINLL *topstaff_mll_p = 0; /* "all" MIDI STUFFS will
+ * be attached here */
+ struct MAINLL *mll_p; /* loop through list */
+ struct MAINLL *m_p; /* to look ahead in list */
+ struct MAINLL *next_p; /* saved next */
+ struct STUFF *nextstuff_p; /* saved next of a STUFF */
+ struct MAINLL *first_p; /* first STAFF at start */
+ struct STUFF *stuff_p; /* loop through STUFF list */
+ struct STUFF *pedal[MAXSTAFFS+1]; /* YES if pedal is down */
+ struct STUFF *saveped[MAXSTAFFS+1]; /* YES if pedal was down * at entry to set of endings */
+ int in_endings; /* YES if inside endings */
+ int i; /* index */
+
+
+ pickup = has_pickup();
+ if ( ( (pickup == YES && start == 0) || (pickup == NO && start == 1) )
+ && end == -1) {
+ /* Use whole song as normal; nothing to do here */
+ return;
+ }
+
+ /* If song has a pickup measure, compensate for that.
+ * This function treats the partial measure as a measure.
+ * So if user specified 0 for start, they want to start at the pickup,
+ * which will be effectively measure 1 here. If they specified 1,
+ * they want to skip the pickup, which means they want to start at
+ * what will be considered measure 2. And so forth.
+ */
+ if (pickup == YES) {
+ if (start >= 0) {
+ start++;
+ }
+ if (end >= 0) {
+ end++;
+ }
+ }
+ else {
+ /* It's not clear if these should be warnings or errors,
+ * but it seems friendlier to be just warnings.
+ * That way, if someone wants the beginning,
+ * but can't remember if the piece has a pickup or not,
+ * they can use 0, and it will always work,
+ * albeit possibly with a warning.
+ */
+ if (start == 0) {
+ warning("x option start of 0 is only valid if there is a pickup measure; using 1");
+ start = 1;
+ }
+ if (end == 0) {
+ warning("x option end of 0 is only valid if there is a pickup measure; using 1");
+ end = 1;
+ }
+ }
+
+ /* Count total number of bars in song */
+ for (numbars = 0, mll_p= Mainllhc_p; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR && mll_p->u.bar_p->bartype != INVISBAR) {
+ numbars++;
+ }
+ /* Multirests count as multiple bars */
+ else if (mll_p->str == S_STAFF
+ && mll_p->u.staff_p->groups_p[0] != 0) {
+ if (mll_p->u.staff_p->groups_p[0]->basictime < -1) {
+ numbars += -(mll_p->u.staff_p->groups_p[0]->basictime) - 1 ;
+ }
+ /* skip the rest of the STAFFs till BAR */
+ while (mll_p->next != 0 && mll_p->next->str == S_STAFF) {
+ mll_p = mll_p->next;
+ }
+ }
+ }
+ if (numbars == 0) {
+ /* Only non-invisible bars count. If there aren't any
+ * identifiable measures, -x is pointless. */
+ ufatal("can't use -x on song with no visible bar lines");
+ }
+
+ /* If user specified things relative to the end, convert
+ * the relative-to-end negative values to relative-to-beginning
+ * positive values.
+ */
+ if (start < 0) {
+ start = numbars + start + 1;
+ }
+ if (end < 0) {
+ end = numbars + end + 1;
+ }
+
+ if (start > numbars) {
+ ufatal("Attempt to start beyond end of song");
+ }
+ if (end < start) {
+ ufatal("Attempt to end before start");
+ }
+ if (end <= 0) {
+ ufatal("Attempt to end before beginning of song");
+ }
+ if (start < 1) {
+ warning("attempt to start before beginning; ignoring");
+ start = 1;
+ }
+ if (end > numbars) {
+ warning("attempt to go past end; ignoring");
+ end = numbars;
+ }
+
+ if (start == 1 && end == numbars) {
+ /* After all the conversions, we ended up with
+ * the entire song. Nothing more to do here. */
+ return;
+ }
+ /* compensate for bar being at end of measure */
+ start--;
+
+
+ /* First find the bar where we're going to start.
+ * Find out if there are any notes tied into that measure
+ * that have an accidental. If so, move the accidental
+ * into the new starting measure.
+ * Note: the 'mll_p != 0' checks are defensive; shouldn't happen.
+ */
+ initstructs();
+ for (bars = 0, mll_p = Mainllhc_p; mll_p != 0 && bars < start;
+ mll_p = mll_p->next){
+ if (mll_p->str == S_SSV) {
+ /* need to keep things like keysig up to date */
+ asgnssv(mll_p->u.ssv_p);
+ }
+ else if (mll_p->str == S_BAR && mll_p->u.bar_p->bartype != INVISBAR) {
+ bars++;
+ }
+ else if (mll_p->str == S_STAFF
+ && mll_p->u.staff_p->groups_p[0] != 0) {
+ if (mll_p->u.staff_p->groups_p[0]->basictime < -1) {
+ bars += -(mll_p->u.staff_p->groups_p[0]->basictime) - 1 ;
+ }
+ /* skip the rest of the STAFFs till BAR */
+ while (mll_p->next->str == S_STAFF) {
+ mll_p = mll_p->next;
+ }
+ }
+ }
+ first_p = 0;
+ for ( ; mll_p != 0 && mll_p->str != S_BAR; mll_p = mll_p->next) {
+ if (mll_p->str == S_STAFF) {
+ mv_accs(mll_p);
+ if (first_p == 0) {
+ first_p = mll_p;
+ }
+ }
+ }
+ /* Fix up the measure number to account for what was chopped off.
+ * The pickup part may be a bit counter-intuitive...
+ * It's because when there was a pickup, we've already added 1 to
+ * "start" for that partial measure; with no pickup, we didn't.
+ * As an example, if user specified -x2, then the measure number
+ * at the barline at the end of the first printed measure should be 3.
+ * "start" will have value 1 if there was no pickup,
+ * but 2 if there was a pickup. So....
+ *
+ * start + 1 + (pickup ? 0 : 1);
+ * -----------------------------
+ * no pickup: 1 + 1 + 1 = 3
+ * pickup: 2 + 1 + 0 = 3
+ */
+ Meas_num = mll_p->u.bar_p->mnum = start + 1 + (pickup ? 0 : 1);
+
+ /* Find the top visible staff on the new effective "first" measure,
+ * We will be moving MIDI STUFFs into the special "extra"
+ * space measure that exists for MIDI right before the first real
+ * measure entered by the user.
+ * The current top visible tells us which staff to use for "all" items.
+ * We leave everything on the list up through the "extra" measure */
+ if (Doing_MIDI) {
+ int staffs_needed; /* number of staffs at new first meas */
+ struct MAINLL *laststaffmll_p = 0; /* last staff of the extra meas
+ * added at the beginning for MIDI.
+ * Initialization just to avoid "used before set." */
+
+ for (mll_p = Mainllhc_p; mll_p->str != S_BAR; mll_p = mll_p->next) {
+ if (mll_p->str == S_STAFF && svpath(
+ mll_p->u.staff_p->staffno, VISIBLE)
+ ->visible == YES) {
+ topstaff_mll_p = mll_p;
+ break;
+ }
+ }
+
+ /* The number of staffs in the "extra" added measure might be
+ * smaller than the number of staffs on the new
+ * effective first measure.
+ */
+ staffs_needed = Score.staffs;
+ for (mll_p = Mainllhc_p; mll_p->str != S_BAR; mll_p = mll_p->next){
+ if (mll_p->str == S_STAFF) {
+ laststaffmll_p = mll_p;
+ }
+ }
+ if (laststaffmll_p == 0){
+ pfatal("extract failed to find last staff in extra measure");
+ }
+ if (laststaffmll_p->u.staff_p->staffno < staffs_needed) {
+ (void) add_pre_meas(laststaffmll_p,
+ laststaffmll_p->u.staff_p->staffno,
+ staffs_needed, NO);
+ }
+
+ /* We want to start discarding things after the extra measure,
+ * so skip past that. */
+ for (mll_p = Mainllhc_p; mll_p->str != S_BAR; mll_p = mll_p->next) {
+ ;
+ }
+ mll_p = mll_p->next;
+ }
+ else {
+ mll_p = Mainllhc_p;
+ }
+
+ /* Pedal is off at the start */
+ for (i = 1; i <= MAXSTAFFS; i++) {
+ pedal[i] = 0;
+ saveped[i] = 0;
+ }
+
+ /* Now go through and discard anything irrelevant before the
+ * start measure. We save all SSVs. If doing MIDI, we save any
+ * MIDI directives that matter.
+ * Everything else gets discarded.
+ */
+ mrbars = 0;
+ next_p = 0;
+ in_endings = NO;
+ for (bars = 0; bars < start; mll_p = next_p) {
+ if (mll_p == 0) {
+ pfatal("got null mll_p when finding starting measure");
+ }
+ next_p = mll_p->next;
+
+ switch (mll_p->str) {
+
+ case S_BAR:
+ if (mll_p->u.bar_p->bartype != INVISBAR) {
+ bars++;
+ }
+ if (mrbars > 0) {
+ bars += mrbars - 1;
+ if (bars > start || (mll_p->u.bar_p->bartype
+ == INVISBAR && bars == start)) {
+ /* New first bar is or was a multirest,
+ * so we need to retain this bar line.
+ */
+ continue;
+ }
+ }
+ mrbars = 0;
+
+ /* Keep track of if we're in a first ending. */
+ if (mll_p->u.bar_p->endingloc == STARTITEM) {
+ in_endings = YES;
+ }
+ else if (mll_p->u.bar_p->endingloc == ENDITEM) {
+ in_endings = NO;
+ }
+ break;
+
+ case S_STAFF:
+ /* Keep track of current pedal state for this staff.
+ * If we find a C_ENDPED the pedal is up, otherwise
+ * it's down (because even with a bounce, at the end
+ * of the bounce, the pedal is down).
+ * Also deal with an octave marks that might spill
+ * over into the new first measure.
+ */
+ for (stuff_p = mll_p->u.staff_p->stuff_p; stuff_p != 0;
+ stuff_p = nextstuff_p) {
+ /* In a previous implementation,
+ * stuff_p->next could be invalid after call
+ * to move_xoct, so we had to save it here.
+ * With the current implementation, this
+ * shouldn't be strictly necessary, but
+ * it doesn't hurt. */
+ nextstuff_p = stuff_p->next;
+
+ /* Note that the only time string should be
+ * null is on pedal carried over from a
+ * previous score, so that isn't really a
+ * change in pedal state, so we can ignore it.
+ */
+ if (stuff_p->stuff_type == ST_PEDAL &&
+ stuff_p->string != 0) {
+ pedal[mll_p->u.staff_p->staffno] =
+ stuff_p;
+ }
+ if (stuff_p->stuff_type == ST_OCTAVE) {
+ move_xoct(stuff_p, first_p,
+ mll_p->u.staff_p->staffno,
+ bars, start);
+ }
+ }
+
+ if (Doing_MIDI) {
+ mv_midi_items(mll_p, topstaff_mll_p);
+ }
+
+ /* Deal with multirest */
+ if (mll_p->u.staff_p->groups_p[0]->basictime < -1) {
+ mrbars = -(mll_p->u.staff_p->groups_p[0]->basictime);
+ if (bars + mrbars > start) {
+ /* Slice starts in middle of multirest.
+ * This multirest will be the new
+ * first measure, but we need
+ * to adjust the number of
+ * measures worth of multirest to
+ * account for starting in the middle
+ * of it.
+ */
+ mll_p->u.staff_p->groups_p[0]->basictime =
+ -((bars + mrbars) - start);
+
+ /* If the end of the slice is also inside
+ * this same multirest, shorten it down
+ * to end there. It's slightly silly to
+ * be saving only a part of a multirest,
+ * but it's better to handle it than
+ * to core dump...
+ */
+ if (bars + mrbars > end) {
+ mll_p->u.staff_p->groups_p[0]->basictime
+ += (end - bars - mrbars + 2);
+ }
+
+ /* If down to single measure, have to
+ * convert from multirest to meas rest */
+ if (mll_p->u.staff_p->groups_p[0]->basictime == -1) {
+ mll_p->u.staff_p->groups_p[0]->is_meas = YES;
+ mll_p->u.staff_p->groups_p[0]->basictime = 1;
+ mll_p->u.staff_p->groups_p[0]->fulltime = Score.time;
+ }
+ continue;
+ }
+ }
+ break;
+
+ case S_SSV:
+ /* Need to keep all the SSVs. Not sure they
+ * really need to be assigned, but shouldn't hurt. */
+ asgnssv(mll_p->u.ssv_p);
+ continue;
+
+ default:
+ break;
+
+ }
+
+ /* Get rid of this MAINLL. User wants it skipped. */
+ unlinkMAINLL(mll_p);
+ }
+
+ /* Make sure there is a bar after where mll_p currently is.
+ * If song consists of just a multirest, followed by
+ * blocks, prints, lines, or curves, but no more music,
+ * we need to force mll_p to get set to the bar at the end of
+ * the multirest.
+ */
+ for (m_p = mll_p; m_p != 0 && m_p->str != S_BAR; m_p = m_p->next) {
+ ;
+ }
+ if (m_p == 0) {
+ /* No bar. Force into hitting the next 'if' */
+ mll_p = 0;
+ }
+
+ /* If start was in a multirest, mll_p could be zero,
+ * so we have to use the beginning bar. */
+ if (mll_p == 0) {
+ for (mll_p = Mainllhc_p; mll_p != 0 && mll_p->str != S_BAR;
+ mll_p = mll_p->next) {
+ ;
+ }
+ if (mll_p == 0) {
+ pfatal("-x option failed to find beginning bar correctly");
+ }
+ }
+
+ /* Add pedal starts if necessary. Go through the new effective
+ * first measure. For any staff that had the pedal down coming
+ * into that measure, make sure the measure starts with a BEGPED.
+ * Also, if there are any measure repeats, ufatal.
+ * Trying to start at a measure repeat doesn't really make a lot of
+ * sense, and it would be work to allow it, so don't bother.
+ * Using mrpt is discouraged anyway.
+ */
+ for ( ; mll_p->str != S_BAR; mll_p = mll_p->next) {
+ if (mll_p->str == S_STAFF) {
+ int v; /* voice index */
+ /* check for mrpt */
+ for (v = 0; v < MAXVOICES; v++) {
+ if (is_mrpt(mll_p->u.staff_p->groups_p[v]) == YES) {
+ l_ufatal(mll_p->inputfile, mll_p->inputlineno,
+ "-x option not allowed to start at a mrpt");
+ }
+ }
+
+ addped(pedal[mll_p->u.staff_p->staffno], mll_p);
+ }
+ }
+
+ /* If slice starts inside an ending, we disallow that.
+ * It turns out there a number of pathological cases,
+ * particularly regarding pedal. If the pedal was down going into
+ * the first ending, but up at the beginning of the slice, then
+ * what should the pedal state be at the start of subsequent endings?
+ * It should normally be based on the state coming into the ending,
+ * but that no longer exists and conflicts with the new "beginning
+ * of the ending" state. And more fundamentally, where do you go back
+ * to when you reach the end of a non-final ending?
+ * There's nothing there to go back to!
+ * I suppose if someone has a really long ending and wants
+ * just the middle of it, this restriction will be annoying,
+ * but that shouldn't happen too often, and trying to handle this
+ * was just getting too complicated!
+ */
+ if (in_endings == YES) {
+ ufatal("-x section not allowed to begin inside an ending");
+ }
+
+ /* If the new first measure is in the middle of an ending,
+ * patch up the endingloc. */
+ if (mll_p->u.bar_p->endingloc == ENDITEM ||
+ mll_p->u.bar_p->endingloc == INITEM) {
+ struct MAINLL *prevmll_p;
+ struct MAINLL *topstaffmll_p = 0;
+
+ for (prevmll_p = mll_p->prev; prevmll_p != 0;
+ prevmll_p = prevmll_p->prev) {
+ if (prevmll_p->str == S_STAFF) {
+ topstaffmll_p = prevmll_p;
+ }
+ else if (prevmll_p->str == S_BAR) {
+ prevmll_p->u.bar_p->endingloc = STARTITEM;
+ break;
+ }
+ }
+ if (prevmll_p == 0) {
+ if (topstaffmll_p == 0) {
+ pfatal("unexpected null topstaffmll_p");
+ }
+ prevmll_p = add_pre_meas(
+ topstaffmll_p->prev, 1, Score.staffs, YES);
+ prevmll_p->u.bar_p->endingloc = STARTITEM;
+ }
+ }
+
+ /* Now chop off end if needed */
+ if (end < numbars) {
+ for ( ; mll_p != 0 && (bars < end || mrbars > 0);
+ mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR && mll_p->u.bar_p->bartype != INVISBAR) {
+ bars++;
+ mrbars = 0;
+ }
+ if (mll_p->str == S_STAFF &&
+ mll_p->u.staff_p->groups_p[0] != 0 &&
+ mll_p->u.staff_p->groups_p[0]->basictime < -1) {
+ /* It's a multirest */
+ mrbars = -(mll_p->u.staff_p->groups_p[0]->basictime);
+ bars += mrbars - 1;
+ if (bars >= end) {
+ /* Slice ends inside the multirest.
+ * Adjust its length. If down to a
+ * single measure, convert */
+ for ( ; mll_p->str == S_STAFF;
+ mll_p = mll_p->next) {
+ mll_p->u.staff_p->groups_p[0]->basictime
+ += bars - end + 1;
+ if (mll_p->u.staff_p->groups_p[0]->basictime == -1) {
+ mll_p->u.staff_p->groups_p[0]->is_meas = YES;
+ mll_p->u.staff_p->groups_p[0]->basictime = 1;
+ mll_p->u.staff_p->groups_p[0]->fulltime = Score.time;
+ }
+ }
+ bars -= bars - end;
+ }
+ /* multi-rest has been handled; skip over
+ * the rest of the staffs in this measure */
+ while (mll_p->next != 0 &&
+ mll_p->next->str == S_STAFF) {
+ mll_p = mll_p->next;
+ }
+ }
+ }
+ if (mll_p != 0) {
+ /* If didn't get all the way to end of main list,
+ * chop off the rest.
+ * We don't bother to free the space.
+ */
+ mll_p->prev->next = 0;
+ Mainlltc_p = mll_p->prev;
+ }
+
+ /* Remove ties/slurs going into the chopped-off part. */
+ for (mll_p = Mainlltc_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p->str == S_STAFF) {
+ int v; /* voice index */
+ for (v = 0; v < MAXVOICES; v++) {
+ struct GRPSYL *g_p;
+ int n; /* note index */
+ if (mll_p->u.staff_p->groups_p[v] == 0) {
+ /* this voice doesn't exist */
+ continue;
+ }
+ /* find last group in this voice */
+ for (g_p = mll_p->u.staff_p->groups_p[v];
+ g_p->next != 0;
+ g_p = g_p->next) {
+ ;
+ }
+ /* only notes can have tie/slur */
+ if (g_p->grpcont != GC_NOTES) {
+ continue;
+ }
+ g_p->tie = NO;
+ for (n = 0; n < g_p->nnotes; n++) {
+ g_p->notelist[n].tie = NO;
+ if (g_p->notelist[n].nslurto > 0) {
+ g_p->notelist[n].nslurto = 0;
+ FREE(g_p->notelist[n].slurtolist);
+ }
+ }
+ }
+
+ if (mll_p->u.staff_p->staffno == 1) {
+ /* No more staffs in the final bar */
+ break;
+ }
+ }
+ }
+
+ /* If end is in the middle of an ending, or with a restart,
+ * fix that */
+ for (mll_p = Mainlltc_p; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p->str == S_BAR) {
+ if (mll_p->u.bar_p->endingloc == INITEM) {
+ mll_p->u.bar_p->endingloc = ENDITEM;
+ }
+ else if (mll_p->u.bar_p->endingloc == STARTITEM) {
+ struct MAINLL *pmll_p;
+
+ /* If there is a previous bar and it's
+ * in an ending, we need to change this
+ * one to an ENDITEM, else to NOITEM.
+ */
+ mll_p->u.bar_p->endingloc = NOITEM;
+ for (pmll_p = mll_p->prev; pmll_p != 0;
+ pmll_p = pmll_p->prev) {
+ if (pmll_p->str == S_BAR) {
+ if (pmll_p->u.bar_p->endingloc == INITEM ||
+ pmll_p->u.bar_p->endingloc == STARTITEM) {
+ mll_p->u.bar_p->endingloc = ENDITEM;
+ }
+ break;
+ }
+ }
+ }
+ if (mll_p->u.bar_p->bartype == RESTART) {
+ /* Not exactly clear what to do here.
+ * Could ufatal. We'll convert to
+ * an invisible bar. */
+ mll_p->u.bar_p->bartype = INVISBAR;
+ }
+ break;
+ }
+ }
+
+ /* Note: it shouldn't be necessary to do anything
+ * about location tags in chopped-off areas.
+ * Locvar code runs much later, so doesn't know
+ * about what was deleted, and that code has to be able
+ * to handle tags pointing to invisible things anyway
+ * for other reasons. Similarly, it is not necessary to
+ * shorten til clauses, since any that spill into the
+ * chopped-off part will still be handled okay, since a
+ * staff could be made invisible in the middle of a til
+ * clause, and this is a similar case.
+ */
+ }
+}
+\f
+
+/* When using -x option, if there is a tie across the beginning split point,
+ * we need to check if there was an accidental on the note being tied from,
+ * and if so, move the accidental to the new effective first measure.
+ */
+
+static void
+mv_accs(mll_p)
+
+struct MAINLL *mll_p;
+
+{
+ int v; /* voice index */
+ int n; /* note index */
+ int staffno;
+ int ea; /* effective accidental */
+ struct GRPSYL *gs_p;
+ struct NOTE *note_p;
+
+ staffno = mll_p->u.staff_p->staffno;
+ for (v = 0; v < MAXVOICES; v++) {
+ if ((gs_p = mll_p->u.staff_p->groups_p[v]) == 0) {
+ /* voice doesn't exist on this staff */
+ continue;
+ }
+ /* Only non-grace note groups can be tied to */
+ if (gs_p->grpcont == GC_NOTES && gs_p->grpvalue != GV_ZERO) {
+ /* check all notes for being tied to */
+ for (n = 0; n < gs_p->nnotes; n++) {
+ note_p = &(gs_p->notelist[n]);
+ /* Only need to check if doesn't already
+ * have an accidental. If effective accidental
+ * differs from what note would get from
+ * key sig, need to add explicit accidental. */
+ if (note_p->accidental == '\0') {
+ ea = eff_acc(gs_p, note_p, mll_p);
+ if (ea != acc_from_keysig(
+ note_p->letter, staffno, mll_p)) {
+ note_p->accidental
+ = Acclets[ea+2];
+ }
+ }
+ }
+ }
+ }
+}
+\f
+
+/* If there is an octave mark whose til clause goes into the new
+ * effective first measure due to -x option, we need to move that octave mark
+ * to that new first measure, with its til clause appropriately shortened.
+ */
+
+static void
+move_xoct(stuff_p, newfirst_p, staffno, bars, start)
+
+struct STUFF *stuff_p; /* the STUFF to potentially move */
+struct MAINLL *newfirst_p; /* points to first STAFF in new first meas */
+int staffno; /* which STAFF this STUFF is for */
+int bars; /* how many bars into song the STUFF is */
+int start; /* start bar number from -x option */
+
+{
+ struct STAFF *staff_p; /* where to move the STUFF */
+ struct MAINLL *mll_p; /* to search for proper STAFF */
+ struct STUFF *newstuff_p; /* moved STUFF */
+
+
+ /* See if this STUFF is an octave that spills into new first measure */
+ if (stuff_p->stuff_type == ST_OCTAVE &&
+ bars + stuff_p->end.bars >= start) {
+ /* Make a new STUFF, adjusting length of til clause
+ * to compensate for -x, and starting at count 1 */
+ newstuff_p = newSTUFF(stuff_p->string,
+ stuff_p->dist,
+ stuff_p->dist_usage,
+ 1.0, 0.0, 0,
+ bars + stuff_p->end.bars - start,
+ stuff_p->end.count,
+ ST_OCTAVE,
+ stuff_p->modifier,
+ stuff_p->place,
+ stuff_p->inputfile,
+ stuff_p->inputlineno);
+
+ /* Find corresponding STAFF in new first measure */
+ staff_p = 0;
+ for (mll_p = newfirst_p; mll_p != 0 && mll_p->str == S_STAFF;
+ mll_p = mll_p->next) {
+ if (mll_p->u.staff_p->staffno == staffno) {
+ staff_p = mll_p->u.staff_p;
+ break;
+ }
+ }
+ if (staff_p == 0) {
+ /* Staff apparently doesn't exist here,
+ * so we can ignore the octave mark. */
+ return;
+ }
+
+ /* Make the octave stuff into a 1-element stufflist,
+ * and call the function to merge that list with the
+ * existing list. */
+ newstuff_p->next = 0;
+ connect_stuff(staff_p, newstuff_p);
+ }
+}
+\f
+
+/* If the passed-in pedal_p points to a pedal stuff that indicates the
+ * pedal state needs to be altered at the beginning of the STAFF passed in,
+ * then do that. This is for -x, for like when the slice begins where the
+ * pedal was held down from the previous measure, so we have to add a begped.
+ */
+
+static void
+addped(pedal_p, mll_p)
+
+struct STUFF *pedal_p; /* last pedal state of previous measures */
+struct MAINLL *mll_p; /* points to a STAFF, to add pedal to */
+
+{
+ int s; /* staff number */
+ struct STUFF *stuff_p; /* walk through stuff list */
+ struct STUFF **prev_p_p; /* This holds the address
+ * of the previous' next,
+ * which is where we will need
+ * to update if we need to delete
+ * or insert a STUFF.
+ */
+
+ s = mll_p->u.staff_p->staffno;
+ if (pedal_p == 0 || pedal_p->string == 0) {
+ /* There is no pedal carrying over into this measure,
+ * so no need to add anything. */
+ return;
+ }
+
+ /* If last pedal mark was an endped, we don't need to move one in,
+ * because pedal is off; otherwise we do. */
+ if (pedal_p->string[4] != C_ENDPED) {
+
+ /* Need to add a pedal STUFF at count 1 if
+ * there isn't already one at or before there.
+ * See if there's already one there.
+ */
+ for (stuff_p = mll_p->u.staff_p->stuff_p,
+ prev_p_p = &(mll_p->u.staff_p->stuff_p);
+ stuff_p != 0;
+ prev_p_p = &(stuff_p->next),
+ stuff_p = stuff_p->next) {
+ if (stuff_p->stuff_type == ST_PEDAL &&
+ stuff_p->start.count
+ <= 1.0) {
+ /* Already had a pedal at beginning of measure.
+ * If it's an ENDPED,
+ * that negates the one coming in,
+ * and it ought to be removed.
+ * If it's a PEDAL, need to change to a BEGPED.
+ * In any case, we don't need
+ * to check any more STUFFs for this STAFF.
+ */
+ if (stuff_p->string[4] == C_ENDPED) {
+ /* delete it */
+ *prev_p_p = stuff_p->next;
+ }
+ else if (stuff_p->string[4] == C_PEDAL) {
+ stuff_p->string[4] = C_BEGPED;
+ }
+ break;
+ }
+ }
+ if (stuff_p == 0) {
+ /* There wasn't a pedal at the
+ * beginning of the new first measure,
+ * so we will need to add one.
+ */
+ struct STUFF *newped_p;
+
+ newped_p = newSTUFF(pedal_p->string,
+ pedal_p->dist,
+ pedal_p->dist_usage,
+ 1.0, 0.0, 0, 0, 0.0,
+ ST_PEDAL,
+ pedal_p->modifier,
+ pedal_p->place,
+ pedal_p->inputfile,
+ pedal_p->inputlineno);
+ newped_p->string[4] = C_BEGPED;
+
+ /* figure out where to insert it */
+ for (stuff_p = mll_p->u.staff_p->stuff_p,
+ prev_p_p = &(mll_p->u.staff_p->stuff_p);
+ stuff_p != 0;
+ prev_p_p = &(stuff_p->next),
+ stuff_p = stuff_p->next) {
+ if (stuff_p->place == PL_ABOVE) {
+ /* not far enough yet */
+ continue;
+ }
+ if (pedal_p->all == YES && stuff_p->all == NO){
+ continue;
+ }
+ if (stuff_p->start.count < 1.0) {
+ continue;
+ }
+ /* found right place */
+ break;
+ }
+ if (prev_p_p == 0) {
+ pfatal("failed to find place to insert pedal for -x");
+ }
+
+ /* insert into STUFF list */
+ newped_p->next = *prev_p_p;
+ *prev_p_p = newped_p;
+ }
+ }
+}
~mdw / mup / blobdiff