Import upstream version 5.3.

[mup] / mup / mup / lyrics.c

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

/* functions called by the parse phase to deal with lyrics */

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


/* information about a measure-worth of lyrics */
struct LYRINFO {
        short   place;          /* PL_ABOVE, etc */
        short   vno;            /* verse number */
        struct  GRPSYL  *gs_p;  /* the lyrics themselves */
        struct LYRINFO  *next;  /* for linked list of other verses on the
                                 * same staff */
};

/* current font/size for each staff/verse/place combination */
struct LYRFONTSIZE {
        short   staffno;
        short   verse;
        char    place;                  /* PL_ABOVE, etc */
        char    font;
        char    size;
        char    all;                    /* YES if "above all" or "below all".
                                         * In that case, the staffno is
                                         * irrelevant */
        struct LYRFONTSIZE *next;       /* linked list */
};

/* we keep the font/size info independently for each staff/verse/place combo
 * and carry it forward from measure to measure. Info is stored here */
struct LYRFONTSIZE *Lyrfontsizeinfo_p [MAXSTAFFS + 1];

/* for each staff, keep a list of all the GRPSYL lyric lists that will be
 * associated with that staff. */
static struct LYRINFO *Lyr_tbl[MAXSTAFFS + 1];

/* need to keep a list of all verse numbers ever used, for setting Maxverses */
static struct RANGELIST *Above_vnumbers_used;
static struct RANGELIST *Below_vnumbers_used;
static struct RANGELIST *Between_vnumbers_used;

/* for auto-numbering verses, keep track of the last verse number used
 * for each staff/place */
static short Prev_verse_num[MAXSTAFFS+1][NUM_PLACE];

/* static function declarations */
static void free_lyrinfo P((struct LYRINFO *lyrinfo_p));
static void assoc_lyr2staff P((int staffno, int verse, struct GRPSYL *gs_p,
                char *lyrstring, int all, int place));
static struct LYRFONTSIZE *getlyrfontsize P((int staffno, int verse,
                int place, int all));
static void updlyrfontsize P((struct LYRFONTSIZE *lyrfontsize_p,
                int font, int size));
static char *next_syl P((char **sylstring_p, int *font_p, int *size_p,
                        short *position_p, int staffno));
static void do_sylwidth P((char *lyrstring, float *wid_b4_syl_p,
                float *wid_real_syl_p, float *wid_after_syl_p,
                int compensating));
static void count_verses P((struct RANGELIST *used_p));
static void vno_used P((int vno));
\f

/* given a range of verses, save the range for later use */

void
lyr_verse(begin, end)

int begin;      /* first verse in range */
int end;        /* last verse number in range */

{
        /* error check */
        /* Note that -1 is a special value meaning "one more than previous."
         * Zero is also special, meaning "centered," but that doesn't
         * get handled by this function, since that doesn't need the error
         * checks that are done here, since the parser guarantees good values.
         * If a zero does get passed in, the user must have explicitly
         * specified it, which is a user error.
         */
        if (begin < 1 && begin != -1) {
                yyerror("verse number must be >= 1");
                return;
        }

        if (end < begin) {
                yyerror("end of verse range smaller than beginning");
                return;
        }

        save_vno_range(begin, end);
}
\f

/* once all the information about a measure-worth of lyrics has been
 * gathered, process it. Break up the lyrics string into syllables and
 * store them in the appropriate GRPSYL structs. Then clone the list as
 * many times as necessary for each staff/verse, and associate with
 * appropriate staffs.
 */

void
proc_lyrics(grpsyl_p, lyrstring)

struct GRPSYL *grpsyl_p;        /* list of GRPSYLs with time values */
char *lyrstring;                /* string containing the lyrics */

{
        struct RANGELIST *slist_p;      /* walk through list of staffs */
        struct RANGELIST *vlist_p;      /* walk through list of verses */
        int staffno;
        int verse;
        int place;


        if (grpsyl_p == (struct GRPSYL *) 0 || lyrstring == (char *) 0) {
                return;
        }

        debug(2, "proc_lyrics file=%s lineno=%d", grpsyl_p->inputfile,
                        grpsyl_p->inputlineno);

        /* for each staff and verse being defined, clone the GRPSYL
         * list and associate with appropriate staff */
        /* do each appropriate staff */
        for (slist_p = Staffrange_p; slist_p !=  (struct RANGELIST *) 0;
                                slist_p = slist_p->next) {
                place = (slist_p->place == PL_UNKNOWN ? PL_BELOW : slist_p->place);
                for (staffno = slist_p->begin; staffno <= slist_p->end;
                                                        staffno++) {

                        /* do each appropriate verse */
                        for (vlist_p = Vnorange_p;
                                        vlist_p != (struct RANGELIST *) 0;
                                        vlist_p = vlist_p->next) {

                                for (verse = vlist_p->begin;
                                                        verse <= vlist_p->end;
                                                        verse++) {

                                        /* -1 means one more than previous */
                                        if (verse == -1) {
                
                                                verse = Prev_verse_num[staffno][place] + 1;
                                        }
                                        Prev_verse_num[staffno][place] = verse;
                                        /* connect to proper staff */
                                        assoc_lyr2staff(staffno, verse,
                                                        grpsyl_p, lyrstring,
                                                        slist_p->all, place);

                                        /* mark that we've use this verse # */
                                        vno_used(verse);
                                }
                        }
                }
        }

        /* free the vno rangelist.  Don't free the staff info yet, because
         * there may be more verses */
        free_vnorange();

        /* the lyrics string has been broken into syllables. Don't need
         * the original string anymore */
        FREE(lyrstring);
}
\f

/* connect a list of syllable to specified STAFF */

static void
assoc_lyr2staff(staffno, verse, gs_p, lyrstring, all, place)

int staffno;            /* which staff lyrics belong to */
int verse;              /* verse number of lyrics */
struct GRPSYL *gs_p;    /* list of GRPSYLs with time information */
char *lyrstring;        /* string of lyrics syllables in this measure/verse */
int all;                /* YES if associated with "all" */
int place;              /* PL_*   */

{
        struct LYRINFO *new_p;                  /* to store info about
                                                 * current staff/verse lyrics */
        struct LYRINFO *lyrinfo_p;              /* used when searching for
                                                 * where to insert this verse */
        struct LYRINFO **insert_place_p_p;      /* address of where to add
                                                 * lyric info when doing
                                                 * insertion sort */
        char *lyr_copy;                         /* copy of lyrics */
        int font;
        int size;
        struct LYRFONTSIZE *lyrfontsize_p;      /* info about font/size for
                                                 * current staff/verse/place */


        debug(4, "assoc_lyr2staff file=%s lineno=%d staffno=%d, verse=%d, all=%d, place=%d",
                        gs_p->inputfile, gs_p->inputlineno, staffno, verse,
                        all, place);

        if (staffno > Score.staffs) {
                l_yyerror(gs_p->inputfile, gs_p->inputlineno,
                        "can't have lyrics for staff %d when there aren't that many staffs",
                        staffno);
                return;
        }

        /* make a copy of the grpsyl list for this staff/verse */
        gs_p = clone_gs_list(gs_p, NO);

        /* allocate space to save info, and fill it in */
        CALLOC(LYRINFO, new_p, 1);
        new_p->vno = (short) verse;
        new_p->place = place;
        new_p->gs_p = gs_p;

        /* insertion sort into list of lyrics for this staff */
        for (insert_place_p_p = & (Lyr_tbl[staffno]);
                        *insert_place_p_p != (struct LYRINFO *) 0;
                        insert_place_p_p = & ((*insert_place_p_p)->next) ) {

                lyrinfo_p = (*insert_place_p_p);

                if ( lyrinfo_p->vno > verse) {
                        /* need to insert new one right before this one */
                        break;
                }

                if ( (lyrinfo_p->vno == verse)
                                        && (lyrinfo_p->place == new_p->place)) {
                        l_yyerror(Curr_filename, yylineno,
                                        "verse %d, staff %d multiply defined",
                                        verse, staffno);
                        return;
                }
        }
        new_p->next = *insert_place_p_p;
        *insert_place_p_p = new_p;

        /* we need to set font/size on a per-staff basis. That means we
         * have to make a temporary copy for each instance and get the
         * syllables each time */
        lyrfontsize_p = getlyrfontsize(staffno, verse, Place, all);
        font = lyrfontsize_p->font;
        size = lyrfontsize_p->size;

        lyr_copy = lyrstring = copy_string(lyrstring + 2, font, size);

        /* get into internal format */
        fix_string(lyrstring, font, size, Curr_filename, yylineno);

        /* skip past the font/size */
        lyrstring += 2;

        /* fill in vno, staffno, and syllables */
        for (   ; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {

                gs_p->staffno = (short) staffno;
                gs_p->vno = (short) verse;

                /* if this GRPSYL is a space, don't fill in a syllable */
                if (gs_p->grpcont == GC_SPACE) {
                        continue;
                }

                /* otherwise, find the next syllable, and store it in
                 * the GRPSYL */
                gs_p->syl = next_syl(&lyrstring, &font, &size,
                                                &(gs_p->sylposition), staffno);
        }

        /* keep track of font/size at end of measure in case we have more
         * lyrics in this same staff/verse/place on a later measure */
        updlyrfontsize(lyrfontsize_p, font, size);

        /* skip over any trailing white space */
        while (*lyrstring == ' ' || *lyrstring == '\t') {
                lyrstring++;
        }

        if (*lyrstring != '\0') {
                yyerror("too many syllables in string");
        }

        /* the copy has been broken into syllables. Free the copy */
        FREE(lyr_copy);
}
\f

/* given a staffno, verse, and place, return (via pointer to struct of info)
 * the font and size that should be used */

static struct LYRFONTSIZE *
getlyrfontsize(staffno, verse, place, all)

int staffno;
int verse;
int place;
int all;        /* YES if associated with "all" */

{
        struct LYRFONTSIZE *lfs_p;      /* walk through linked list */


        /* if this staff/verse/place is on the list, use the values stored
         * there. */
        for (lfs_p = Lyrfontsizeinfo_p [staffno];
                                        lfs_p != (struct LYRFONTSIZE *) 0;
                                        lfs_p = lfs_p->next) {

                if (lfs_p->staffno == staffno && lfs_p->verse == verse
                                && lfs_p->place == place && lfs_p->all == all) {
                        return(lfs_p);
                }
        }

        /* wasn't on list yet. Add to list, using default values from SSV */
        MALLOC(LYRFONTSIZE, lfs_p, 1);
        lfs_p->staffno = (short) staffno;
        lfs_p->verse = (short) verse;
        lfs_p->place = (char) place;
        lfs_p->all = (char) all;
        if (all == YES) {
                lfs_p->font = (char) (Score.lyricsfamily + Score.lyricsfont);
                lfs_p->size = (char) Score.lyricssize;
        }
        else {
                lfs_p->font = svpath(staffno, LYRICSFAMILY)->lyricsfamily
                                + svpath(staffno, LYRICSFONT)->lyricsfont;
                lfs_p->size = svpath(staffno, LYRICSFONT)->lyricssize;
        }
        lfs_p->next = Lyrfontsizeinfo_p [ staffno ];
        Lyrfontsizeinfo_p [ staffno ] = lfs_p;

        return(lfs_p);
}
\f

/* update values of font/size for a given LYRFONTSIZE struct */

static void
updlyrfontsize(lyrfontsize_p, font, size)

struct LYRFONTSIZE *lyrfontsize_p;
int font;
int size;

{
        lyrfontsize_p->font = (char) font;
        lyrfontsize_p->size = (char) size;
}
\f

/* when user sets lyricsfont via an SSV, that overrides whatever fonts are
 * currently in effect, so change them. */

void
setlyrfont(staffno, font)

int staffno;
int font;

{
        int s;                          /* index through staffs */
        struct LYRFONTSIZE *lfs_p;      /* info about font/size */


        if (Context == C_SCORE) {
                Context = C_STAFF;
                /* reset all staffs */
                for (s = 1; s <= Score.staffs; s++) {
                        setlyrfont(s, font);
                }
                Context = C_SCORE;
        }
        else {
                /* set all place/verse combinations of given staff */
                for (lfs_p = Lyrfontsizeinfo_p [staffno];
                                        lfs_p != (struct LYRFONTSIZE *) 0;
                                        lfs_p = lfs_p->next) {
                        lfs_p->font = (lfs_p->all == YES ? Score.lyricsfamily
                                + Score.lyricsfont
                                : svpath(staffno, LYRICSFAMILY)->lyricsfamily
                                + font);
                }
        }
}
\f

/* when user sets lyricsize via an SSV, that overrides whatever fonts are
 * currently in effect, so change them. */

void
setlyrsize(staffno, size)

int staffno;
int size;

{
        int s;                          /* index through staffs */
        struct LYRFONTSIZE *lfs_p;      /* font/size info */


        if (Context == C_SCORE) {
                /* reset all staffs */
                Context = C_STAFF;
                for (s = 1; s <= Score.staffs; s++) {
                        setlyrsize(s, size);
                }
                Context = C_SCORE;
        }
        else {
                /* set all place/verse combinations of given staff */
                for (lfs_p = Lyrfontsizeinfo_p [staffno];
                                        lfs_p != (struct LYRFONTSIZE *) 0;
                                        lfs_p = lfs_p->next) {
                        lfs_p->size = (char) (lfs_p->all == YES
                                        ? Score.lyricssize : size);
                }
        }
}
\f

/* This function is called when an entire measure has been collected, to
 * take care of all the lyrics.
 * For each staff, allocate the proper number of elements for the syls_p
 * list and fill them in.
 * Then free all the LYRINFO structs and clean out the Lyr_tbl.
 */

void
attach_lyrics2staffs(mll_staffs_p)

struct MAINLL *mll_staffs_p;    /* the list of staffs to attch to */

{
        struct STAFF *staff_p;          /* the staff we are currently dealing
                                         * with */
        int verses;                     /* how many verses for staff */
        struct LYRINFO *lyrinfo_p;      /* where lyrics info is stored */


        debug(4, "attach_lyrics2staffs");

        /* do each staff */
        for (   ; mll_staffs_p != (struct MAINLL *) 0;
                                        mll_staffs_p = mll_staffs_p->next) {

                if (mll_staffs_p->str != S_STAFF) {
                        /* must have gotten to end of staffs; done */
                        break;
                }

                /* need staff pointer a lot. Get shorter name for it */
                staff_p = mll_staffs_p->u.staff_p;

                /* count up how many verses there are associated with this
                 * staff */
                for ( verses = 0, lyrinfo_p = Lyr_tbl[staff_p->staffno];
                                        lyrinfo_p != (struct LYRINFO *) 0;
                                        lyrinfo_p = lyrinfo_p->next) {
                        verses++;
                }

                /* if no verses, nothing to do */
                if (verses == 0) {
                        continue;
                }

                /* alloc space for the appropriate number of verses */
                MALLOC(GRPSYL *, staff_p->syls_p, verses);
                if ((staff_p->sylplace = (short *) malloc
                                (sizeof(short) * verses)) == (short *) 0) {
                        l_no_mem(__FILE__, __LINE__);
                }
                staff_p->nsyllists = (short) verses;

                /* now attach the GRPSYLs and set the places for each */
                for (verses = 0, lyrinfo_p = Lyr_tbl[staff_p->staffno];
                                        lyrinfo_p != (struct LYRINFO *) 0;
                                        lyrinfo_p = lyrinfo_p->next, verses++) {

                        staff_p->syls_p[verses] = lyrinfo_p->gs_p;
                        staff_p->sylplace[verses] = lyrinfo_p->place;
                }

                free_lyrinfo(Lyr_tbl[staff_p->staffno]);
                Lyr_tbl[staff_p->staffno] = (struct LYRINFO *) 0;
        }
}
\f

/* recursively free list of LYRINFO structs */

static void
free_lyrinfo(lyrinfo_p)

struct LYRINFO *lyrinfo_p;      /* the list to free */

{
        if (lyrinfo_p == (struct LYRINFO *) 0) {
                return;
        }

        free_lyrinfo(lyrinfo_p->next);
        FREE(lyrinfo_p);
}
\f

/* At each bar line, reset previous verse number for auto-verse-numbering */

void
lyr_new_bar()
{
        int staff_index;
        int place_index;

        for (staff_index = 1; staff_index <= MAXSTAFFS; staff_index++) {
                for (place_index = 0; place_index < NUM_PLACE; place_index++) {
                        Prev_verse_num[staff_index][place_index] = 0;
                }
        }
}

\f

/* in several places we need to copy part of a lyric from one string to
 * another while keeping track of the font and size changes along the way.
 * Doing this with a function gets hard to think about because you'd
 * have to pass around a bunch of pointers to pointers and keep all the
 * levels of indirection straight, so I opted for a macro.
 * destbuff is the char array into which to copy. destindex is the subscript
 * into that array. src_p is a char * from which to copy. delimiter is the
 * character at which to stop copying. fnt_p and sz_p are pointer to font
 * and size which need to be updated if the font or size change.
 */
#define COPY_LYR(destbuff, destindex, src_p, delimiter, fnt_p, sz_p) \
        for (   ; *src_p != '\0' && *src_p != delimiter; src_p++) { \
                destbuff[destindex++] = *src_p; \
                                                \
                switch ( (unsigned) *src_p & 0xff) { \
                case STR_FONT: \
                        *fnt_p = *++src_p; \
                        destbuff[destindex++] = *src_p; \
                        break; \
                case STR_SIZE: \
                        *sz_p = *++src_p; \
                        destbuff[destindex++] = *src_p; \
                        break; \
                case STR_MUS_CHAR: \
                        destbuff[destindex++] = *++src_p; \
                        destbuff[destindex++] = *++src_p; \
                        break; \
                case STR_BACKSPACE: \
                        destbuff[destindex++] = *++src_p; \
                        break; \
                default: \
                        break; \
                } \
        }
\f


/* break a string of lyrics into individual syllables. The following
 * characters are special:
 *      <space>         marks end of syllable
 *      <tab>           same as space
 *      -               end of syllable
 *      _               end of syllable
 *      '<'             beginning of non-lyric item
 *      '>'             end of non-lyric item
 */
/* Each syllable will be returned as a string of the form:
 *      <font> <size> [<STR_PRE> pre-item <STR_PRE_END>] syllable [<STR_PST> post-item <STR_PST_END>]
 * where
 *      <font> is a 1-byte font identifier, FONT_TR, FONT_TI etc
 *      <size> is a 1-byte size, in points
 *      if there is non-lyrics stuff to be put before the lyric syllable, it
 *              will be surrounded by <STR_PRE> and <STR_PRE_END> characters.
 *              It may contain other commands for font changes, etc.
 *              This field is optional. If present it may be of arbitrary
 *              length, including zero length
 *              If this text is to be used for syllable
 *              placement, the header will be <STR_U_PRE> instead
 *      The syllable follows. It may contain any of the commands found in
 *              any other string. It can be of zero length.
 *      Optionally, there may there something to print after the syllable
 *              that isn't part of the syllable. If there is such a thing,
 *              it will be surrounded by <STR_PST> and <STR_PST_END> characters.
 *              If this text is to be used for syllable placement, the
 *              header will be <STR_U_PST> instead.
 *      Any of the fields can be of zero length, but at least one of them
 *              must be of non-zero length for each syllable to be sensible.
 * This function should be called after the string has been transformed
 * to internal format, with font/size changes stored as commands.
 * If a syllable starts with a positioning value, that is updated.
 */

static char *
next_syl(sylstring_p, font_p, size_p, position_p, staffno)

char **sylstring_p;     /* address of pointer to current spot in lyric string
                         * of syllables. At entry, its contents should be
                         * the address of the first character of the syllable
                         * to be returned. On return, its contents will be
                         * updated to point to the first character of the
                         * following syllable, to be ready for the next call
                         * to this function.
                         */
int *font_p;            /* pointer to current font value, will be updated
                         * with new font if it changes. */
int *size_p;            /* pointer to current size value; will be updated
                         * with new size if it changes */
short *position_p;      /* pointer to sylposition field, will be updated
                         * with the user-specified position value, if
                         * they specified one, otherwise will be left as is. */
int staffno;            /* which staff this syllable is for */

{
        char *p;                /* pointer into lyrics string */
        int done;               /* boolean to keep track of if we are done */
        int font, size;         /* original font and size */
        int i;                  /* index into sylbuff */
        char sylbuff[BUFSIZ];   /* temporary storage for a syllable */


        /* initialize */
        sylbuff[0] = '\0';
        i = 0;
        font = *font_p;
        size = *size_p;

        /* skip any leading white space */
        for (p = *sylstring_p; *p != '\0'; p++) {
                if (*p != ' ') {
                        break;
                }
        }

        /* see if we have a non-lyrics before the lyric */
        if ( *p == '<') {

                /* we do have a non-lyric. Put in the header, and copy up
                 * to the '>', keeping track of any font/size changes
                 * along the way */
                if (*(p+1) == '^') {
                        sylbuff[i++] = (char) STR_U_PRE;
                        p++;
                }
                else {
                        sylbuff[i++] = (char) STR_PRE;
                }
                p++;
                COPY_LYR(sylbuff, i, p, '>', font_p, size_p);

                /* add in the > marker */
                sylbuff[i++] = (char) STR_PRE_END;
                if (*p == '\0') {
                        yyerror("missing '>' in lyric");
                }
                else {
                        p++;
                }
        }

        /* see if user gave a position value */
        if (*p == '|') {
                /* use default value from parameter */
                *position_p = svpath(staffno, SYLPOSITION)->sylposition;
                p++;
        }
        else if ( isdigit(*p) ||
                        ( (*p == '-' || *p == '+') && isdigit(*(p+1)) ) ) {
                char *after_num_p;
                int value;

                /* if there is a pipe after the number, it's a position */
                value = strtol(p, &after_num_p, 10);
                if ( *after_num_p == '|') {
                        *position_p = value;
                        p = after_num_p + 1;
                }
        }

        /* now collect the lyric syllable itself */
        for ( done = NO; *p != '\0' && i < BUFSIZ; p++) {

                switch ( (unsigned) *p & 0xff) {

                case ' ':
                case '\t':
                        /* definitely end of this lyric syllable */
                        done = YES;
                        break;


                case '~':
                        /* two syllables joined into one. Replace the ~
                         * by a space */
                        sylbuff[i++] = ' ';
                        p++;
                        break;

                case '-':
                case '_':
                        /* end of syllable */
                        /* need to peek ahead to check for non-lyric following */
                        sylbuff[i++] = *p++;
                        if ( *p != '<') {
                                done = YES;
                                break;
                        }
                        /*FALLTHRU*/

                case '<':
                        if (*(p+1) == '^') {
                                sylbuff[i++] = (char) STR_U_PST;
                                p++;
                        }
                        else {
                                sylbuff[i++] = (char) STR_PST;
                        }
                        p++;
                        COPY_LYR(sylbuff, i, p, '>', font_p, size_p);

                        sylbuff[i++] = (char) STR_PST_END;
                        p++;
                        /* A ~ joins this syllable with the next to make
                         * them effectively one, but anything else ends
                         * the syllable. But copy - or _ if they are there */
                        if ( *p != '~') {
                                if (*p == '-' || *p == '_') {
                                        sylbuff[i++] = *p++;
                                }
                                done = YES;
                        }
                        break;

                case STR_FONT:
                        sylbuff[i++] = *p++;
                        *font_p = *p;
#ifdef EXTCHAR
                        if (*font_p >= FONT_XTR) {
                                sylbuff[i++] = *p++;
                        }
#endif
                        break;

                case STR_SIZE:
                        sylbuff[i++] = *p++;
                        *size_p = *p;
                        break;

                case STR_BACKSPACE:
                        sylbuff[i++] = *p++;
                        break;

                case STR_MUS_CHAR:
                        sylbuff[i++] = *p++;
                        sylbuff[i++] = *p++;
                        break;

                case STR_BOX:
                        yyerror("boxed text not allowed in lyrics");
                        break;

                case STR_BOX_END:
                        break;

                case STR_CIR:
                        yyerror("circled text not allowed in lyrics");
                        break;

                case STR_CIR_END:
                        break;

                case STR_PILE:
                        yyerror("\\: not allowed in lyric syllable");
                        break;

                case STR_C_ALIGN:
                case STR_L_ALIGN:
                        yyerror("alignment not allowed in lyric syllable");
                        break;

                default:
                        break;
                }

                if (done == NO) {
                        sylbuff[i++] = *p;
                }
                else {
                        break;
                }
        }

        sylbuff[i] = '\0';

        if (i == 0) {
                yyerror("too few syllables in string");
        }

        /* prepare for next call to this function */
        *sylstring_p = p;

        /* return a copy of the extracted syllable */
        return(copy_string(sylbuff, font, size));
}
\f

/* given a syllable string, return the width (in inches) of the non-lyric
 * parts and of the actual syllable */

void
sylwidth(lyrstring, wid_b4_syl_p, wid_real_syl_p, wid_after_syl_p)

char *lyrstring;
float *wid_b4_syl_p;    /* width of leading non-lyrics will be put here */
float *wid_real_syl_p;  /* width of actual syllable will be put here */
float *wid_after_syl_p; /* width of trailing non-lyric will be put here */

{
        do_sylwidth(lyrstring, wid_b4_syl_p, wid_real_syl_p, wid_after_syl_p,
                                                        NO);
}
\f

/* find width of syllable and <...> things. When called in placement phase
 * we count the <^...> and don't count <...>. When called in print phase
 * we do the opposite to compensate.
 */

static void
do_sylwidth(lyrstring, wid_b4_syl_p, wid_real_syl_p, wid_after_syl_p,
                compensating)

char *lyrstring;
float *wid_b4_syl_p;    /* width of leading non-lyrics will be put here */
float *wid_real_syl_p;  /* width of actual syllable will be put here */
float *wid_after_syl_p; /* width of trailing non-lyric will be put here */
int compensating;       /* YES if being called from print phrase when we
                         * have to compensate for the fact that <...> may
                         * not have been used in placement. */

{
        int pre_counts = NO;    /* if pre width should be included */
        int post_counts = NO;   /* if post width should be included */
        int had_post = NO;      /* if had post <...> */
        float w1 = 0.0;         /* width of pre */
        float w2 = 0.0;         /* width of pre + syllable */
        float w3;               /* width of entire string */
        char *p;
        char save;              /* temp storage */
        

        if (lyrstring == (char *) 0) {
                *wid_b4_syl_p = *wid_real_syl_p = *wid_after_syl_p = 0.0;
                return;
        }

        for (p = lyrstring; *p != '\0'; p++) {
                switch ( (unsigned) *p & 0xff) {
                case STR_PRE:
                        if (compensating == YES) {
                                pre_counts = YES;
                        }
                        break;
                case STR_U_PRE:
                        if (compensating == NO) {
                                pre_counts = YES;
                        }
                        break;
                case STR_PRE_END:
                        /* get width of string so far. Temporarily shorten
                         * string to this point and get its length. This
                         * will be the length of the preceeding <...> */
                        *p = '\0';
                        w1 = strwidth(lyrstring);
                        *p = (char) STR_PRE_END;
                        break;
                case STR_U_PST:
                        /* get width of string so far. Temporarily shorten
                         * string to this point and get its length. This
                         * will be the length of the syllable and its
                         * preceeding <...> */
                        if (compensating == NO) {
                                post_counts = YES;
                        }
                        save = *p;
                        *p = '\0';
                        w2 = strwidth(lyrstring);
                        *p = save;
                        had_post = YES;
                        break;
                case STR_PST:
                        if (compensating == YES) {
                                post_counts = YES;
                        }
                        save = *p;
                        *p = '\0';
                        w2 = strwidth(lyrstring);
                        *p = save;
                        had_post = YES;
                        break;
                default:
                        break;
                }
        }

        /* get length of entire string */
        w3 =  strwidth(lyrstring);

        /* if there wasn't a post <...> we didn't yet get the width of
         * the syllable plus preceeding <...> */
        if (had_post == NO) {
                w2 = w3;
        }

        /* now calculate and return the widths */
        *wid_b4_syl_p = (pre_counts == YES ? w1 : 0.0);
        *wid_real_syl_p = w2 - w1;
        *wid_after_syl_p = (post_counts == YES ? w3 - w2 : 0.0);
}
\f

/* during placement phase, <...> things were used or not used as appropriate
 * for setting placement. During print phrase, we do the opposite to
 * compensate, and update the group east and west boundaries as necessary */
void
lyr_compensate(gs_p)

struct GRPSYL *gs_p;

{
        float pre_wid, syl_wid, post_wid;

        do_sylwidth(gs_p->syl, &pre_wid, &syl_wid, &post_wid, YES);
        gs_p->c[AW] -= pre_wid;
        gs_p->c[AE] += post_wid;
}
\f

/* every time a verse number is used, see whether we've already had that
 * verse number before. if not, add it to the list of verse numbers used. */
/* We could keep each range of defined verses in a RANGELIST, so that,
 * for example, 1-3 could be keep in a single struct. However, trying to
 * coalese the list could get very hairy, so do the simple-minded way of
 * saving each unique verse number in its own struct. We could also
 * insertion sort the list, but rarely will there be more than a couple
 * verses, and inserting into a singly linked list takes a slight amount
 * of work, so be very lazy and just search the whole list each time and
 * insert at beginning if need to add to list. */

static void
vno_used(vno)

int vno;        /* the verse number to check */

{
        struct RANGELIST *v_p;  /* to walk through list of verse nums used */
        struct RANGELIST **list_p_p;    /* which list to check */


        switch (Place) {
        case PL_ABOVE:
                list_p_p = &Above_vnumbers_used;
                break;
        case PL_BETWEEN:
                list_p_p = &Between_vnumbers_used;
                break;
        case PL_BELOW:
        case PL_UNKNOWN:
                list_p_p = &Below_vnumbers_used;
                break;
        default:
                pfatal("illegal place in vno_used");
                /*NOTREACHED*/
                return;
        }

        /* see if this verse is already on the list */
        for (v_p = *list_p_p; v_p != (struct RANGELIST *) 0; v_p = v_p->next) {
                if (v_p->begin == vno) {
                        /* already had this verse before */
                        return;
                }
        }

        /* must not have seen this verse number before, so add it */
        CALLOC(RANGELIST, v_p, 1);
        v_p->begin = (short) vno;
        /* ->end is not used in this list */
        v_p->next = *list_p_p;
        *list_p_p = v_p;
}
\f

/* when parsing is complete, we can find out how many unique verse numbers
 * there were in the input */

void
set_maxverses()
{
        debug(4, "set_maxverses");

        count_verses(Above_vnumbers_used);
        count_verses(Below_vnumbers_used);
        count_verses(Between_vnumbers_used);
}

/* recursively walk down list of verse numbers used. Count them up and
 * free them while unwinding */

static void
count_verses(used_p)

struct RANGELIST *used_p;

{
        if (used_p == (struct RANGELIST *) 0) {
                return;
        }

        count_verses(used_p->next);
        Maxverses++;
        FREE(used_p);
}
\f

/* Return pointer to the SSV that contains the default timeunit information
 * for verses being defined. Make sure if there are multiple staffs
 * being defined, they all have the same default timeunit. If there is only
 * one voice on the staff, use that for default. If there are 2 voices, if the
 * place is PL_ABOVE use voice 1, otherwise use voice 2. */

struct SSV *
get_lyr_dflt_timeunit_ssv()

{
        struct RANGELIST *staffrange_p; /* to index through list of staffs */
        struct SSV *ssv_p;              /* containing relevent timeunit */
        struct SSV *ref_ssv_p;          /* to ensure consistency */
        RATIONAL timeunit;              /* timeunit for current staff */
        RATIONAL reference_timeunit;    /* the timeunit found on previous
                                         * staff, for comparison to make sure
                                         * they are the same */
        int staff;


        reference_timeunit = Zero;
        /* if all else fails, use Score value */
        ssv_p = ref_ssv_p = &Score;

        /* go down the list of staffs, get timeunit for each */
        for (staffrange_p = Staffrange_p;
                                        staffrange_p != (struct RANGELIST *) 0;
                                        staffrange_p = staffrange_p->next) {

                for (staff = staffrange_p->begin; staff <= staffrange_p->end;
                                                staff++) {

                        /* get appropriate default timeunit value */
                        if (svpath(staff, VSCHEME)->vscheme == V_1 ||
                                                Place == PL_ABOVE) {
                                ssv_p = vvpath(staff, 1, TIMEUNIT);
                        }
                        else {
                                ssv_p = vvpath(staff, 2, TIMEUNIT);
                        }
                        timeunit = ssv_p->timeunit;

                        /* check for consistency */
                        if ( NE(reference_timeunit, Zero) ) {
                                if ( NE(timeunit, reference_timeunit) ||
                                                timelists_equal(
                                                ssv_p->timelist_p,
                                                ref_ssv_p->timelist_p) == NO) {
                                        /*  have a mis-match. Give error message,
                                         * and return the first timeunit we got.
                                         * No reason to check any more, because
                                         * all that may happen is that we'll
                                         * print lots more error messages for
                                         * the same problem. */
                                        yyerror("timeunit value must be the same for all lyric staffs being defined on the same input line");
                                        return(ssv_p);
                                }
                        }
                        else {
                                /* first time through. Now we have a timeunit
                                 * to use for default */
                                reference_timeunit = timeunit;
                                ref_ssv_p = ssv_p;
                        }
                }
        }

        /* Used to pfatal if couldn't find default value. However, that can
         * happen if user specifies an invalid staff number, so that isn't
         * a program bug, but a user error. The user error would already have
         * been flagged, so no reason to complain at all here */

        return(ssv_p);
}
\f

/* user wants us to derive the lyrics time values from corresponding music
 * time values. Find the proper list of GRPSYLs to copy time values from,
 * and make a copy of that list, with field set properly for lyrics. */

struct GRPSYL *
derive_lyrtime()

{
        struct MAINLL *mll_p;           /* to find STAFF to derive from */
        struct GRPSYL *new_list_p;      /* the list of derived time values */
        struct GRPSYL *gs_p;            /* to walk through new_list_p */
        struct GRPSYL *ref_gs_p;        /* to walk through the reference list--
                                         * the list we are deriving from */
        int staff, voice;               /* which list of GRPSYLs to clone */


        /* If there are no staffs associated with these lyrics, then nothing
         * to do here. We should have already printed an error elsewhere */
        if (Staffrange_p == (struct RANGELIST *) 0) {
                return (struct GRPSYL *) 0;
        }

        /* find the proper music GRPSYL from which to derive time values */
        staff = leadstaff();
        for (mll_p = Mainlltc_p; mll_p != (struct MAINLL *) 0;
                                                mll_p = mll_p->prev) {

                /* if back up all the way to a bar, user hasn't defined the
                 * right staff's music input yet */
                if (mll_p->str == S_BAR) {
                        /* pretend we fell off top of list and break out.
                         * That way we only need one copy of error message code */
                        mll_p = (struct MAINLL *) 0;
                        break;
                }
                if (mll_p->str == S_STAFF && mll_p->u.staff_p->staffno == staff) {
                        /* found the right staff data */
                        break;
                }
        }

        if (mll_p == (struct MAINLL *) 0) {
                l_yyerror(Curr_filename, yylineno,
                        "can't derive lyrics time values: staff %d music not defined yet", staff);
                return (struct GRPSYL *) 0;
        }

        /* usually use voice 1 of first staff specified. Only exceptions
         * are if voice 1 is invisible or nonexistent or if explicitly below,
         * and there is a visible voice 2, in which case voice 2 is used */
        voice = 0;
        if ((vvpath(staff, 1, VISIBLE)->visible == NO ||
                        mll_p->u.staff_p->groups_p[0] == (struct GRPSYL *) 0
                        || Place == PL_BELOW)
                        && mll_p->u.staff_p->groups_p[1] != (struct GRPSYL *) 0
                        && vvpath(staff, 2, VISIBLE)->visible == YES) {
                voice = 1;
        }
        /* One more exception. If both voices are invisible, but we would
         * have used voice 2 if it was visible, use voice 2. Otherwise
         * if times would normally be derived from voice 2, but the
         * whole staff is invisible, we could derive the wrong values. */
        if (vvpath(staff, 1, VISIBLE)->visible == NO &&
                        vvpath(staff, 2, VISIBLE)->visible == NO &&
                        mll_p->u.staff_p->groups_p[1] != (struct GRPSYL *) 0 &&
                        Place == PL_BELOW) {
                voice = 1;
        }

        if (mll_p->u.staff_p->groups_p[voice] == (struct GRPSYL *) 0) {
                l_yyerror(Curr_filename, yylineno,
                        "can't derive lyrics time values: staff %d voice %d music not defined yet", staff, voice + 1);
                return (struct GRPSYL *) 0;
        }

        new_list_p = clone_gs_list(mll_p->u.staff_p->groups_p[voice], NO);

        /* grace notes don't count in the time derivation, so remove
         * them from the cloned list */
        for (gs_p = new_list_p; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {
                if (gs_p->grpvalue == GV_ZERO) {
                        struct GRPSYL *to_free_p;
                        to_free_p = gs_p;
                        if (gs_p->prev == 0) {
                                new_list_p = gs_p->next;
                        }
                        else {
                                gs_p->prev->next = gs_p->next;
                        }
                        /* Note that there should always be a 'next' after
                         * a grace note, so this 'if' shouldn't really be
                         * necessary, but it is here as defensive code. */
                        if (gs_p->next != 0) {
                                gs_p->next->prev = gs_p->prev;
                        }
                        FREE(to_free_p);
                }
        }

        /* go through cloned list, changing type to lyrics and changing rests
         * in the music to spaces for the lyrics. Also deal with ties and slurs,
         * since notes that are tied or slurred to will be treated like a
         * space, since there is probably only a single syllable wanted. */
        for (gs_p = new_list_p, ref_gs_p = mll_p->u.staff_p->groups_p[voice];
                        gs_p != (struct GRPSYL *) 0;
                        gs_p = gs_p->next, ref_gs_p = ref_gs_p->next) {
                /* Skip graces in reference list. (There aren't any in
                 * the new list since we removed them above.) */
                while (ref_gs_p->grpvalue == GV_ZERO) {
                        ref_gs_p = ref_gs_p->next;
                        if (ref_gs_p == 0) {
                                /* should be impossible to get here */
                                pfatal("unexpected null ref_gs_p in derive_lyrtime");
                        }
                }

                gs_p->grpsyl = GS_SYLLABLE;
                if (ref_gs_p->grpcont == GC_REST) {
                        gs_p->grpcont = GC_SPACE;
                }
                else if (ref_gs_p->grpcont == GC_NOTES && ref_gs_p->nnotes > 0) {
                        /* if the top note of the chord is tied or slurred,
                         * or the entire chord is tied,
                         * make the following lyrics GRPSYL, if any, a space. */
                        if ((ref_gs_p->notelist[0].tie == YES ||
                                        ref_gs_p->tie == YES ||
                                        ref_gs_p->notelist[0].nslurto > 0) &&
                                        gs_p->next != (struct GRPSYL *) 0) {
                                gs_p->next->grpcont = GC_SPACE;
                        }
                }
        }

        /* One more detail: if the first note was tied-to or slurred-to from
         * the previous measure, we have to change that to a space. To do that,
         * we call prevgrpsyl, but it expects the staffno and vno to be filled
         * in on the GRPSYL passed to it, and we're so early in parsing that
         * that hasn't happened yet. So first have to patch that up. Later on,
         * all the GRPSYLs will get the staffno and vno filled in, but it won't
         * hurt anything that we've already done this one here; they will
         * just be overwritten with the same values. */
        ref_gs_p = mll_p->u.staff_p->groups_p[voice];
        ref_gs_p->staffno = mll_p->u.staff_p->staffno;
        ref_gs_p->vno = voice + 1;
        if ((gs_p = prevgrpsyl(ref_gs_p, &mll_p)) != (struct GRPSYL *) 0) {
                if (gs_p->grpcont == GC_NOTES && gs_p->nnotes > 0) {
                        if (gs_p->notelist[0].tie == YES ||
                                        gs_p->tie == YES ||
                                        gs_p->notelist[0].nslurto > 0) {
                                new_list_p->grpcont = GC_SPACE;
                        }
                }
        }

        return (new_list_p);
}