Debianize new mup version

[mup] / mup / mup / map.c

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

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

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

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

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

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

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

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

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

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

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

/* Initialize Input_style to default of IS_VOICE_INPUT */

void
reset_input_style()

{
        int staff;
        int voice;

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

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

int
input_style(staff, voice)

int staff;
int voice;

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

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

void
begin_map()

{
        struct MAP *new_p;


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

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

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

        begin_sv_list();
}
\f

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

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

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

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

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

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

void
end_map()

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

        begin_range(Place);
}
\f

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

static int
map_groups()

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        clean_map_data();

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

        return(YES);
}
\f

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

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

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

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


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

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

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

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

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

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

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

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

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

static void
clean_map_data()

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

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

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

static void
free_maps(map_p)

struct MAP *map_p;

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

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

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

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

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

static void
free_notemaps(notemap_p)

struct NOTEMAP *notemap_p;

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

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

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

static struct NOTEMAP *
find_notemap(num_notes)

int num_notes;

{
        struct MAP *m_p;

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

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

void
link_groups()

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

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

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

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

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

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

static void
do_link_groups()

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


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

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

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

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

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

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

static void
link_a_grouplist(staffno, vno, copies)

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

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

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

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

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

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

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

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

static void
convert_rest_space(grpsyl_p, staffno, vno)

struct GRPSYL *grpsyl_p;
int staffno;
int vno;

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

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

static void
conv_grpsyl(grpsyl_p, staffno, vno)

struct GRPSYL *grpsyl_p;
int staffno;
int vno;

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

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

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

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

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

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

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

struct SSV *
get_dflt_timeunit_ssv()

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


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

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

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

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

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

        return(tu_ssv_p);
}
\f

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

int
timelists_equal(list1_p, list2_p)

struct TIMELIST *list1_p;
struct TIMELIST *list2_p;

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

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

int
is_tab_range()

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

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

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

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

        return(found_tab_staff);
}
\f

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

void
merge_dup_notes(gs_p, n)

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

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


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

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

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


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

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

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

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

/* print error message for multiply defined voice */

static void
mult_def(staff, voice)

int staff;
int voice;

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