--- /dev/null
+
+/* 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);
+}
+
~mdw / mup / blobdiff