--- /dev/null
+
+/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by Arkkra Enterprises */
+/* All rights reserved */
+
+/* functions related to characters: information about the size and shape of
+ * characters to be printed, to initialize the internal tables
+ * to tell how big each character is, etc.
+ */
+
+#include <string.h>
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+
+/* code for invalid music character */
+#define BAD_CHAR '\377'
+/* code for invalid number in user input string */
+#define BAD_NUMBER -30000
+
+/* machine-generated sorted list for translating
+ * music character names to internal code numbers. */
+/* The +1 is because there is an "end-of-list" entry with charname == 0 */
+extern struct SPECCHAR Mus_char_table[NUM_MFONTS][CHARS_IN_FONT+1];
+#ifdef EXTCHAR
+extern struct SPECCHAR Ext_char_table[];
+#endif
+
+
+/* save information about characters in string as we go, in order to be
+ * able to backspace back over them */
+struct BACKSPACEINFO {
+ char code;
+ char font;
+};
+
+
+#ifndef __STDC__
+extern char *bsearch(); /* binary search library function */
+#endif
+extern long strtol();
+
+/* static functions */
+static char *get_font P((char *string, int *font_p, int prev_font, char *fname,
+ int lineno));
+static char *get_num P((char *string, int *num_p));
+static int sc_compare P((const void *item1_p, const void *item2_p));
+#ifdef EXTCHAR
+static unsigned char ext_name2num P((char *name));
+#endif
+static int starts_piled P((char *string, int *font_p, int *size_p,
+ char **pile_start_p_p));
+static int str_cmd P((char *str, int *size_p, int *in_pile_p));
+static int get_accidental P((unsigned char *str, char *accidental_p,
+ int *acc_size_p, int trans_natural, int *escaped_p));
+static int add_accidental P((char *buff, int acc_character, int acc_size,
+ int escaped));
+static int dim_tri P((unsigned char *str, char *replacement,
+ int size, int is_chord));
+static int smallsize P((int size));
+static int accsize P((int size));
+\f
+
+/* return the height (in inches) of a character of specified font and size */
+
+double
+height(font, size, ch)
+
+int font;
+int size;
+int ch; /* which character */
+
+{
+ int chval;
+
+ chval = ch & 0xff;
+
+ /* control characters have no height */
+ if (chval < FIRST_CHAR) {
+ return(0.0);
+ }
+
+ return((Fontinfo[ font_index(font) ].ch_height[ CHAR_INDEX(chval) ]
+ / FONTFACTOR) * ((float)size / (float)DFLT_SIZE) );
+}
+\f
+
+/* return the width (in inches) of a character of specified font and size */
+
+double
+width(font, size, ch)
+
+int font;
+int size;
+int ch; /* which character */
+
+{
+ int chval;
+
+ chval = ch & 0xff;
+
+ /* control characters have no width */
+ if (chval < FIRST_CHAR) {
+ return(0.0);
+ }
+
+ return((Fontinfo[ font_index(font) ].ch_width[ CHAR_INDEX(chval) ]
+ / FONTFACTOR) * ((float)size / (float)DFLT_SIZE) );
+}
+\f
+
+/* return the ascent (in inches) of a character of specified font and size */
+
+double
+ascent(font, size, ch)
+
+int font;
+int size;
+int ch; /* which character */
+
+{
+ int chval;
+
+ chval = ch & 0xff;
+
+ /* control characters have no ascent */
+ if (chval < FIRST_CHAR) {
+ return(0.0);
+ }
+
+ return((Fontinfo[ font_index(font) ].ch_ascent[ CHAR_INDEX(chval) ]
+ / FONTFACTOR) * ((float) size / (float)DFLT_SIZE) );
+}
+\f
+
+/* return the descent (in inches) of a character of specified font and size */
+
+double
+descent(font, size, ch)
+
+int font;
+int size;
+int ch; /* which character */
+
+{
+ return ( height(font, size, ch) - ascent(font, size, ch) );
+}
+\f
+
+/* given a user input string, normalize it. This means:
+ * Put the default font in [0] and default size in [1] of the string.
+ * Change backslashed things to internal format. Each starts with a
+ * hyper-ASCII code byte and is followed by one or more data bytes.
+ * Note that in all cases in internal format is no longer than the
+ * incoming format.
+ * Change any \f(XX) to STR_FONT font_number
+ * Change any \s(NN) to STR_SIZE actual_size
+ * Note that NN might have a sign to indicate relative size change.
+ * Change any \v(NN) to STR_VERTICAL vertical_offset
+ * Note that NN might have a sign to indicate direction,
+ * negative means downward.
+ * Change any \/ to STR_SLASH
+ * Change any \| to STR_L_ALIGN (piled mode only)
+ * Change any \^ to STR_C_ALIGN (piled mode only)
+ * Change any backslashed space to space when in piled mode
+ * Change any space to newline while in piled mode
+ * Change \(xxxx) to STR_MUS_CHAR size mus_char_code
+ * Change \% to STR_PAGENUM %
+ * Change \# to STR_NUMPAGES #
+ * Change \n to newline
+ * Change \b to STR_BACKSPACE n
+ * where n is how much to back up for the
+ * default size, in BACKSP_FACTORths of an inch
+ * Change backslashed backslash or double quote to just be themselves.
+ * Reject any other control characters or illegal backslash escapes.
+ * The string is null-terminated.
+ *
+ * The normalized string is put back into the original string buffer
+ * that was passed in, and a pointer to it is returned.
+ *
+ * Note that some functions in lyrics.c, and prntdata.c
+ * also have knowledge of the escape conventions,
+ * so if these change, check there too. But it is intended
+ * that all the rest of the code gets at strings indirectly
+ * via functions in this file, so the details can be hidden here.
+ */
+
+char *
+fix_string(string, font, size, fname, lineno)
+
+char *string; /* original string */
+int font; /* default font for string */
+int size; /* default size for string */
+char *fname; /* file name, for error messages */
+int lineno; /* input line number, for error messages */
+
+{
+ char *tmpbuff; /* for normalized string */
+ int leng; /* strlen(string) + 1 */
+ char *inp_p, *out_p; /* walk thru orig & normalized string */
+ int nsize; /* new size */
+ int prevsize; /* previous size */
+ int msize; /* size for music character */
+ int vert; /* argument to \v without sign */
+ int vertval = 0; /* signed argument to \v */
+ int has_vertical = NO; /* YES if \v or pile found */
+ int has_newline = NO; /* YES if \n somewhere in string */
+ int pile_mode = NO;
+ int align_points = 0; /* how many aligments points found */
+ int error; /* YES if have found an error */
+ char spec_name[100], *sc_p; /* name of special music character, or
+ * extended character set character */
+ unsigned char extchar; /* value for extended character */
+ unsigned char muschar; /* value for music character */
+ int now_font; /* current font */
+ int newfont; /* proposed new font */
+ int prevfont; /* previous font */
+ int mfont; /* music font */
+ struct BACKSPACEINFO *backspaceinfo; /* font/size for backspacing */
+ int backspaceindex = 0; /* index into backspaceinfo */
+ float backup; /* backspace distance in inches
+ * for default size */
+ int backupval; /* value to store for backspace
+ * distance */
+
+
+ /* fill in default font and size */
+ string[0] = (char) font;
+ if (rangecheck(size, MINSIZE, MAXSIZE, "size") == NO) {
+ size = MAXSIZE;
+ }
+ string[1] = (char) size;
+ now_font = prevfont = font;
+ prevsize = size;
+
+ leng = strlen(string) + 1;
+ MALLOCA(char, tmpbuff, leng);
+ MALLOC(BACKSPACEINFO, backspaceinfo, leng);
+ /* walk through incoming string, creating normalized string */
+ for (error = NO, out_p = tmpbuff + 2, inp_p = string + 2;
+ (error == NO) && (*inp_p != '\0');
+ inp_p++, out_p++) {
+
+ /* handle backslashed stuff */
+ if (*inp_p == '\\') {
+
+ /* skip past the backslash */
+ inp_p++;
+
+ switch( *inp_p) {
+
+ case '\n':
+ /* ignore the backslashed newline */
+ out_p--;
+ break;
+
+ case '\r':
+ if (*(inp_p) == '\n') {
+ inp_p++;
+ }
+ out_p--;
+ break;
+
+ case 'f':
+ /* font change */
+ inp_p = get_font(++inp_p, &newfont, prevfont,
+ fname, lineno);
+ if (newfont == FONT_UNKNOWN) {
+ error = YES;
+ }
+ else {
+ *out_p++ = (char) STR_FONT;
+ *out_p = (char) newfont;
+ prevfont = now_font;
+ now_font = newfont;
+ }
+ break;
+
+ case 's':
+ /* size change */
+ if (*++inp_p == '(') {
+ switch (*++inp_p) {
+ case '+':
+ inp_p = get_num(++inp_p, &nsize);
+ if (nsize > 0) {
+ nsize += size;
+ }
+ break;
+ case '-':
+ inp_p = get_num(++inp_p, &nsize);
+ if (nsize > 0) {
+ nsize = size - nsize;
+ }
+ break;
+ case 'P':
+ if (strncmp(inp_p, "PV)", 3) == 0) {
+ nsize = prevsize;
+ inp_p += 2;
+ }
+ else {
+ nsize = BAD_NUMBER;
+ }
+ break;
+ case 'p':
+ if (strncmp(inp_p, "previous)", 9) == 0) {
+ nsize = prevsize;
+ inp_p += 8;
+ }
+ else {
+ nsize = BAD_NUMBER;
+ }
+ break;
+ default:
+ inp_p = get_num(inp_p, &nsize);
+ break;
+ }
+ }
+ else {
+ nsize = BAD_NUMBER;
+ }
+
+ /* if got valid size, store it */
+ if (nsize == BAD_NUMBER) {
+ l_yyerror(fname, lineno,
+ "Invalid format for size value");
+ error = YES;
+ }
+ else if (rangecheck(nsize, MINSIZE,
+ MAXSIZE, "size") == YES) {
+ *out_p++ = (char) STR_SIZE;
+ *out_p = (char) nsize;
+ /* save new size */
+ prevsize = size;
+ size = nsize;
+ }
+ else {
+ error = YES;
+ }
+
+ break;
+
+ case 'v':
+ /* vertical motion */
+ if (*++inp_p == '(') {
+ switch (*++inp_p) {
+ case '-':
+ inp_p = get_num(++inp_p, &vert);
+ if (vert >= 0) {
+ vertval = -vert;
+ }
+ break;
+
+ case '+':
+ ++inp_p;
+ /* fall through */
+ default:
+ inp_p = get_num(inp_p, &vert);
+ if (vert >= 0) {
+ vertval = vert;
+ }
+ break;
+ }
+ }
+ else {
+ vert = BAD_NUMBER;
+ }
+
+ if (vert == BAD_NUMBER) {
+ l_yyerror(fname, lineno,
+ "Invalid format for vertical motion value");
+ error = YES;
+ }
+ else if (rangecheck(vertval, -100, 100,
+ "vertical") == YES) {
+ /* if motion is zero, don't even bother
+ * to save it, else do */
+ if (vertval != 0) {
+ /* convert percentage to
+ * STR_VERTICAL units */
+ if (vertval > 0) {
+ vertval = vertval *
+ MAXVERTICAL/100;
+ }
+ else {
+ vertval = -vertval *
+ MINVERTICAL/100;
+ }
+ *out_p++ = (char) STR_VERTICAL;
+ *out_p = (char) ENCODE_VERT(
+ vertval );
+ }
+ }
+ else {
+ error = YES;
+ }
+
+ /* we don't allow backspacing to something
+ * before a vertical motion--this is almost
+ * like a newline. */
+ backspaceindex = 0;
+
+ has_vertical = YES;
+
+ break;
+
+ case ':':
+ /* If this begins a pile, and the next thing
+ * in input ends the pile, just ignore them
+ * both to keep things simpler later. */
+ if (pile_mode == NO && *(inp_p+1) == '\\'
+ && *(inp_p+2) == ':') {
+ inp_p += 2;
+ /* no output character */
+ out_p--;
+ }
+ else {
+ *out_p = (char) STR_PILE;
+ has_vertical = YES;
+ pile_mode = (pile_mode == YES ? NO : YES);
+ }
+ align_points = 0;
+ break;
+
+ case '|':
+ case '^':
+ if (pile_mode == NO) {
+ l_yyerror(fname, lineno,
+ "alignment point only allowed in piled mode");
+ *out_p = *inp_p;
+ }
+
+ else if (++align_points > 1) {
+ l_yyerror(fname, lineno,
+ "only one alignment point allowed per line");
+ *out_p = *inp_p;
+ }
+
+ else if (*inp_p == '^') {
+ int next_ch;
+ *out_p = (char) STR_C_ALIGN;
+ next_ch = *(inp_p+1) & 0xff;
+ /* it's too much trouble to handle
+ * things like font changes between
+ * the \^ and the character that
+ * will be allowed, so disallow them,
+ * since user can easily put them
+ * before the \^ anyway. */
+ if ( (IS_STR_COMMAND(next_ch)
+ && next_ch != STR_MUS_CHAR)
+ || *(inp_p+1) == ' '
+ || iscntrl(*(inp_p+1)) ) {
+ l_yyerror(fname, lineno,
+ "\\^ must be followed by normal character");
+ }
+ }
+ else {
+ *out_p = (char) STR_L_ALIGN;
+ }
+ has_vertical = YES;
+ break;
+
+ case ' ':
+ if (pile_mode == NO) {
+ l_yyerror(fname, lineno,
+ "backslashed space only allowed in piled mode");
+ }
+ *out_p = ' ';
+ break;
+
+ case '/':
+ /* This is only allowed after one
+ * or more digits */
+ if ( inp_p - string < 4 ||
+ ! isdigit( *(inp_p - 2)) ) {
+ l_yyerror(fname, lineno,
+ "slash can only be used after digit(s)");
+ }
+ *out_p = (char) STR_SLASH;
+ break;
+ case '\\':
+ case '"':
+ /* real backslash or embedded quote, copy it */
+ backspaceinfo[backspaceindex].code = *inp_p;
+ backspaceinfo[backspaceindex++].font
+ = (char) now_font;
+ *out_p = *inp_p;
+ break;
+
+ case '(':
+ /* special music character or extended
+ * character set character */
+ /* make copy of name */
+ for ( sc_p = spec_name, inp_p++;
+ *inp_p != ')' && *inp_p != '\0';
+ sc_p++, inp_p++) {
+ *sc_p = *inp_p;
+ }
+ *sc_p = '\0';
+
+#ifdef EXTCHAR
+ /* first see if it is a character in the
+ * extended character set */
+ if ((extchar = ext_name2num(spec_name))
+ != (unsigned char) BAD_CHAR) {
+ /* temporarily change to the extended
+ * character set font that corresponds
+ * to the current normal ASCII font,
+ * and output the extended character
+ * set code for the desired character.
+ * Then go back to original font */
+ *out_p++ = (char) STR_FONT;
+ *out_p++ = (char)
+ (now_font + EXT_FONT_OFFSET);
+ *out_p++ = extchar;
+ *out_p++ = (char) STR_FONT;
+ *out_p = (char) now_font;
+ backspaceinfo[backspaceindex].code
+ = extchar;
+ backspaceinfo[backspaceindex++].font
+ = now_font + EXT_FONT_OFFSET;
+
+ /* mark that this extended character
+ * set font has been used */
+ Font_used[now_font + EXT_FONT_OFFSET] = YES;
+
+ break;
+ }
+#endif
+ /* look up music character with this name */
+ msize = size;
+ if ((muschar = mc_name2num(spec_name, fname,
+ lineno, &msize, &mfont))
+ != (unsigned char) BAD_CHAR) {
+ *out_p++ = (char) mfont2str(mfont);
+ *out_p++ = (char) msize;
+ *out_p = muschar;
+ backspaceinfo[backspaceindex].code
+ = muschar;
+ backspaceinfo[backspaceindex++].font
+ = FONT_MUSIC;
+ }
+ break;
+
+ case '[':
+ /* start of boxed text. We only allow this at
+ * the beginning of a string */
+ if (inp_p != string + 3) {
+ l_yyerror(fname, lineno,
+ "\\[ only allowed at beginning of string");
+ error = YES;
+ }
+ else {
+ *out_p = (char) STR_BOX;
+ }
+ break;
+
+ case ']':
+ /* end of boxed text. Only allowed at end of
+ * string, and only if the string began
+ * with a box start. */
+ if (*(inp_p + 1) != '\0') {
+ l_yyerror(fname, lineno,
+ "\\] only allowed at end of string");
+ error = YES;
+ }
+ else if (IS_BOXED(tmpbuff) == NO) {
+ l_yyerror(fname, lineno,
+ "no matching \\[ for \\]");
+ error = YES;
+ }
+ else {
+ *out_p = (char) STR_BOX_END;
+ }
+ break;
+
+ case '{':
+ /* start of circled text. We only allow this at
+ * the beginning of a string */
+ if (inp_p != string + 3) {
+ l_yyerror(fname, lineno,
+ "\\{ only allowed at beginning of string");
+ error = YES;
+ }
+ else {
+ *out_p = (char) STR_CIR;
+ }
+ break;
+
+ case '}':
+ /* end of circled text. Only allowed at end of
+ * string, and only if the string began
+ * with a circle start. */
+ if (*(inp_p + 1) != '\0') {
+ l_yyerror(fname, lineno,
+ "\\} only allowed at end of string");
+ error = YES;
+ }
+ else if (IS_CIRCLED(tmpbuff) == NO) {
+ l_yyerror(fname, lineno,
+ "no matching \\{ for \\}");
+ error = YES;
+ }
+ else {
+ *out_p = (char) STR_CIR_END;
+ }
+ break;
+
+ case '%':
+ /* too hard to deal with inside a pile... */
+ if (pile_mode == YES) {
+ l_yyerror(fname, lineno,
+ "\\%c not allowed inside a pile\n", '%');
+ }
+
+ /* page number -- change to STR_PAGENUM-% */
+ *out_p++ = (char) STR_PAGENUM;
+ *out_p = '%';
+ /* we really don't know at this point how far
+ * to backspace over pagenum because we don't
+ * know yet how many digits it is, etc, so we
+ * punt and just use the % character
+ * for width */
+ backspaceinfo[backspaceindex].code = '%';
+ backspaceinfo[backspaceindex++].font
+ = (char) now_font;
+ break;
+
+ case '#':
+ /* code basically the same as for % */
+ if (pile_mode == YES) {
+ l_yyerror(fname, lineno,
+ "\\# not allowed inside a pile\n");
+ }
+
+ /* number of pages -- change to STR_NUMPAGES-# */
+ *out_p++ = (char) STR_NUMPAGES;
+ *out_p = '#';
+ /* We really don't know at this point how far
+ * to backspace, because we don't know yet
+ * how many digits it is, etc, so we punt
+ * and just use the # character for width. */
+ backspaceinfo[backspaceindex].code = '#';
+ backspaceinfo[backspaceindex++].font
+ = (char) now_font;
+ break;
+
+ case 'n':
+ /* newline */
+ *out_p = '\n';
+ /* can't back up to previous line */
+ backspaceindex = 0;
+ has_newline = YES;
+ break;
+
+ case 'b':
+ /* can't back up past beginning of string */
+ if (backspaceindex == 0) {
+ if (has_newline == YES || has_vertical == YES) {
+ l_yyerror(fname, lineno,
+ "can't backspace before newline or vertical motion");
+ }
+ else {
+ l_yyerror(fname, lineno,
+ "can't backspace before beginning of line");
+ }
+ error = YES;
+ }
+ else {
+ backspaceindex--;
+ backup = width(backspaceinfo
+ [backspaceindex].font,
+ DFLT_SIZE, backspaceinfo
+ [backspaceindex].code);
+ *out_p++ = (char) STR_BACKSPACE;
+ /* calculate backup value to store */
+ backupval = (int) (backup * BACKSP_FACTOR);
+ if (backupval < 1) {
+ backupval = 1;
+ }
+ else if (backupval > 127) {
+ backupval = 127;
+ }
+ *out_p = (char) backupval;
+ }
+ break;
+
+ default:
+ yyerror("illegal \\ escape");
+ error = YES;
+ break;
+ }
+ }
+
+ else if (iscntrl(*inp_p) ) {
+ if (*inp_p == '\n') {
+ backspaceindex = 0;
+ has_newline = YES;
+ *out_p = *inp_p;
+ }
+ else if (*inp_p == '\r' && *(inp_p+1) == '\n') {
+ /* ignore DOS's extraneous \r */
+ out_p--;
+ }
+ else {
+ /* We don't support any other control
+ * characters, but just convert others to
+ * space and continue. That way user at least
+ * gets something. Tab is something user may
+ * expect to work, so we give a more clear
+ * and specific error for that.
+ */
+ l_warning(fname, lineno,
+ "unsupported control character '\\0%o' %sin string replaced with space",
+ *inp_p, *inp_p =='\t' ? "(tab) ": "");
+ *out_p = ' ';
+ }
+ }
+ else if (pile_mode == YES && *inp_p == ' ') {
+ /* in piled mode, space means move down for next
+ * item in pile. */
+ *out_p = '\n';
+
+ align_points = 0;
+ backspaceindex = 0;
+ }
+ else {
+ /* normal character -- copy as is */
+ *out_p = *inp_p;
+ backspaceinfo[backspaceindex].code = *inp_p;
+ backspaceinfo[backspaceindex++].font = (char) now_font;
+ }
+ }
+ /* If we got an error, we would not have put anything into the
+ * final output position before incrementing out_p in the 'for' loop,
+ * so compensate, so we don't leave a garbage character. */
+ if (error == YES) {
+ out_p--;
+ }
+ *out_p = '\0';
+
+ if (error == NO && IS_BOXED(tmpbuff) == YES &&
+ (*(out_p - 1) & 0xff) != (STR_BOX_END & 0xff)) {
+ l_yyerror(fname, lineno, "no matching \\] for \\[");
+ }
+
+ if (error == NO && IS_CIRCLED(tmpbuff) == YES &&
+ (*(out_p - 1) & 0xff) != (STR_CIR_END & 0xff)) {
+ l_yyerror(fname, lineno, "no matching \\} for \\{");
+ }
+
+ /* to keep things simple, we don't allow
+ * mixing newlines with vertical motion */
+ if (has_vertical == YES && has_newline == YES) {
+ l_yyerror(fname, lineno,
+ "can't have newline in same string with vertical motion or alignment");
+ }
+
+ /* now copy normalized string back onto original */
+ (void) strcpy(string + 2, tmpbuff + 2);
+ FREE(tmpbuff);
+ FREE(backspaceinfo);
+ return(string);
+}
+\f
+
+/* given pointer into a string, read a font name exclosed in parentheses.
+ * Return the corresponding font number, or
+ * FONT_UNKNOWN if name is invalid. Return pointer to last character
+ * processed in string */
+
+static char *
+get_font(string, font_p, prev_font, fname, lineno)
+
+char *string; /* get font from this string */
+int *font_p; /* return new font via this pointer */
+int prev_font; /* previous font */
+char *fname; /* file name for errors */
+int lineno; /* line number, for error messages */
+
+{
+ char fontname[BUFSIZ];
+ int font = FONT_UNKNOWN;
+ char *endparen; /* where ')' is in string */
+ int length; /* of font name */
+
+
+ if (*string == '(') {
+ string++;
+ if ((endparen = strchr(string, ')')) != (char *) 0) {
+ length = endparen - string;
+ (void) strncpy(fontname, string, (unsigned) length);
+ fontname[length] = '\0';
+ string += length;
+ if (strcmp(fontname, "PV") == 0
+ || strcmp(fontname, "previous") == 0) {
+ /* special case of "previous" font */
+ font = prev_font;
+ }
+ else {
+ font = lookup_font(fontname);
+ }
+ }
+ }
+
+ *font_p = font;
+ if (font == FONT_UNKNOWN) {
+ l_yyerror(fname, lineno, "unknown font specified");
+ }
+ return(string);
+}
+\f
+
+/* given a pointer into a string, get a number followed by close parenthesis.
+ * Return the number via pointer, or BAD_NUMBER on error.
+ * Return pointer to the last character processed
+ * in the incoming string */
+
+static char *
+get_num(string, num_p)
+
+char *string; /* get number from this string */
+int *num_p; /* return number via this pointer, or -1 on error */
+
+{
+ if (isdigit(*string)) {
+ *num_p = strtol(string, &string, 10);
+ if (*string != ')') {
+ *num_p = BAD_NUMBER;
+ }
+ }
+ else {
+ *num_p = BAD_NUMBER;
+ }
+ return(string);
+}
+\f
+
+/* compare the charname fields of 2 SPECCHAR structs and return
+ * their proper order, for comparison by bsearch() */
+
+static int
+sc_compare(item1_p, item2_p)
+
+#ifdef __STDC__
+const void *item1_p; /* there are really struct SPECCHAR *, but bsearch
+ * passes them as char * and we have to
+ * cast appropriately */
+const void *item2_p;
+#else
+char *item1_p; /* there are really struct SPECCHAR *, but bsearch passes them
+ * as char * and we have to cast appropriately */
+char *item2_p;
+#endif
+
+{
+ return(strcmp( ((struct SPECCHAR *)(item1_p))->charname,
+ ((struct SPECCHAR *)(item2_p))->charname));
+}
+\f
+
+/* given the name of a music character, return its code number.
+ * If the name is not a valid name, return BAD_CHAR.
+ * Just do a binary search in the name-to-code translation table.
+ */
+
+unsigned char
+mc_name2num(name, fname, lineno, size_p, font_p)
+
+char *name; /* name for a music character */
+char *fname; /* file name for error messages */
+int lineno; /* input line number for error messages */
+int *size_p; /* points to current size, proper size for music character
+ * is returned through here */
+int *font_p; /* FONT_MUSIC* is returned here */
+
+{
+ struct SPECCHAR *info_p;/* translation entry for the given name */
+ struct SPECCHAR key; /* what to look for */
+ int f; /* font index */
+ static unsigned int numch[NUM_MFONTS]; /* how many items in font */
+
+
+ /* first time through, find size of name-to-code table */
+ if (numch[0] == 0) {
+ for (f = 0; f < NUM_MFONTS; f++) {
+ for ( ; Mus_char_table[f][numch[f]].charname != (char *)0;
+ (numch[f])++) {
+ ;
+ }
+ }
+ }
+
+ /* check for "small" characters */
+ if (name[0] == 's' && name[1] == 'm') {
+ key.charname = name + 2;
+ *size_p = smallsize(*size_p);
+ }
+ else {
+ key.charname = name;
+ }
+
+ /* do binary search for code */
+ for (f = 0; f < NUM_MFONTS; f++) {
+ if ((info_p = (struct SPECCHAR *) bsearch((char *) &key, Mus_char_table[f],
+ numch[f], sizeof(struct SPECCHAR), sc_compare))
+ != (struct SPECCHAR *) 0) {
+ *font_p = FONT_MUSIC + f;
+ return( (unsigned char) info_p->code);
+ }
+ }
+
+ l_yyerror(fname, lineno, "unknown music character '%s'", name);
+ *font_p = FONT_MUSIC;
+ return( (unsigned char) BAD_CHAR);
+}
+#ifdef EXTCHAR
+\f
+
+/* given the name of an extended character set character,
+ * return its code number.
+ * If the name is not a valid name, return BAD_CHAR.
+ * Just do a binary search in the name-to-code translation table.
+ */
+
+static unsigned char
+ext_name2num(name)
+
+char *name; /* name for an extended character set character */
+
+{
+ struct SPECCHAR *info_p;/* translation entry for the given name */
+ struct SPECCHAR key; /* what to look for */
+ static unsigned int numch = 0; /* how many items in xlation table */
+ char shortcut[12]; /* full name of shortcutted character */
+
+
+ /* find size of name-to-code table */
+ if (numch == 0) {
+ for ( ; Ext_char_table[numch].charname != (char *) 0;
+ numch++) {
+ ;
+ }
+ }
+
+ key.charname = name;
+
+ /* allow some shortcuts for common diacritical marks. A letter
+ * followed by one of '`^~:/,vo represents acute, grave, circumflex,
+ * tilde, dieresis, slash, cedilla, caron, and ring.
+ * And as a special case, ss represents germandbls */
+ if (strlen(name) == 2 && isalpha(name[0])) {
+ switch (name[1]) {
+ case '\'':
+ (void) sprintf(shortcut, "%cacute", name[0]);
+ key.charname = shortcut;
+ break;
+ case '`':
+ (void) sprintf(shortcut, "%cgrave", name[0]);
+ key.charname = shortcut;
+ break;
+ case '^':
+ (void) sprintf(shortcut, "%ccircumflex", name[0]);
+ key.charname = shortcut;
+ break;
+ case '~':
+ (void) sprintf(shortcut, "%ctilde", name[0]);
+ key.charname = shortcut;
+ break;
+ case ':':
+ (void) sprintf(shortcut, "%cdieresis", name[0]);
+ key.charname = shortcut;
+ break;
+ case '/':
+ (void) sprintf(shortcut, "%cslash", name[0]);
+ key.charname = shortcut;
+ break;
+ case ',':
+ (void) sprintf(shortcut, "%ccedilla", name[0]);
+ key.charname = shortcut;
+ break;
+ case 'v':
+ (void) sprintf(shortcut, "%ccaron", name[0]);
+ key.charname = shortcut;
+ break;
+ case 'o':
+ (void) sprintf(shortcut, "%cring", name[0]);
+ key.charname = shortcut;
+ break;
+ case 's':
+ if (name[0] == 's') {
+ (void) sprintf(shortcut, "germandbls");
+ key.charname = shortcut;
+ }
+ break;
+ default:
+ /* not a special shortcut, leave as is */
+ break;
+ }
+ }
+ /* Some more special case shortcuts: `` and '' are shortcuts for
+ * quotedblleft and quotedblright, and << and >> for guillemots */
+ if (strcmp(name, "``") == 0) {
+ key.charname = "quotedblleft";
+ }
+ else if (strcmp(name, "''") == 0) {
+ key.charname = "quotedblright";
+ }
+ else if (strcmp(name, "<<") == 0) {
+ key.charname = "guillemotleft";
+ }
+ else if (strcmp(name, ">>") == 0) {
+ key.charname = "guillemotright";
+ }
+
+ /* do binary search for code */
+ if ((info_p = (struct SPECCHAR *) bsearch((char *) &key, Ext_char_table,
+ numch, sizeof(struct SPECCHAR), sc_compare))
+ != (struct SPECCHAR *) 0) {
+ return( (unsigned char) info_p->code);
+ }
+
+ else {
+ /* don't do error message here, because it could just be a
+ * music character rather than an extended character set char */
+ return( (unsigned char) BAD_CHAR);
+ }
+}
+#endif
+\f
+
+/* given the C_XXX code value for a music character, return the
+ * user name for the character. The first time this function gets
+ * called it sets up a translation array. Then it can just look up
+ * the name by using the code as an index into the array */
+
+char *
+mc_num2name(code, font)
+
+int code; /* the code for the music character */
+int font; /* FONT_MUSIC* */
+
+{
+ static int xlate_tbl[NUM_MFONTS][CHARS_IN_FONT + FIRST_CHAR];
+ /* translate music char #define
+ * values to offset in Mus_char_table
+ * array */
+ int f; /* font index */
+ static int called = NO; /* boolean, YES if this function
+ * has been called before */
+ register int numch; /* how many music characters to do */
+
+
+ if (called == NO) {
+ called = YES;
+ /* first time. need to build table */
+
+ /* For each item in the Mus_char_table, fill in the
+ * element of the xlate_tbl array with its offset,
+ * or fill in -1 if no valid character with that code. */
+ for (f = 0; f < NUM_MFONTS; f++) {
+ for ( numch = 0; numch < CHARS_IN_FONT + FIRST_CHAR; numch++) {
+ xlate_tbl[f][numch] = -1;
+ }
+ }
+ for (f = 0; f < NUM_MFONTS; f++) {
+ for ( numch = 0; numch < CHARS_IN_FONT + FIRST_CHAR; numch++) {
+ if (Mus_char_table[f][numch].charname != 0) {
+ xlate_tbl [f] [ Mus_char_table[f][numch].code & 0xff ] =
+ numch;
+ }
+ else {
+ break;
+ }
+ }
+ }
+ }
+
+ /* now we just look up the name */
+ if ((numch = xlate_tbl[font - FONT_MUSIC][code & 0xff]) < 0) {
+ pfatal("bad music character [%d][%d] in mc_num2name",
+ font - FONT_MUSIC, code & 0xff);
+ }
+
+ return( Mus_char_table[font - FONT_MUSIC][numch].charname );
+}
+#ifdef EXTCHAR
+\f
+
+/* given the C_XXX code value for an extended character set char, return the
+ * user name for the character. The first time this function gets
+ * called it sets up a translation array. Then it can just look up
+ * the name by using the code as an index into the array */
+
+char *
+ext_num2name(code)
+
+int code; /* the code for the extended character set character */
+
+{
+ static int xlate_tbl[CHARS_IN_FONT + FIRST_CHAR];
+ /* translate extended char
+ * #define values to offset in
+ * Ext_char_table array */
+ static int called = NO; /* boolean, YES if this function
+ * has been called before */
+ register int numch; /* how many extended characters to do */
+
+
+ if (called == NO) {
+ called = YES;
+ /* first time. need to build table */
+
+ /* initialize table to have nothing set */
+ for ( numch = 0; numch < CHARS_IN_FONT + FIRST_CHAR; numch++) {
+ xlate_tbl[numch] = -1;
+ }
+
+ /* for each item in the Ext_char_table, fill in the
+ * element of the xlate_tbl array with its offset */
+ for (numch = 0; Ext_char_table[numch].charname != (char *) 0;
+ numch++) {
+ xlate_tbl [ Ext_char_table[numch].code & 0xff ] =
+ numch;
+ }
+ }
+
+ /* now we just look up the name */
+ if ((numch = xlate_tbl[code & 0xff]) < 0) {
+ pfatal("bad extended character set character (%d) in ext_num2name", code & 0xff);
+ }
+
+ return( Ext_char_table[numch].charname );
+}
+#endif
+\f
+
+/* return YES if string passed in consists solely of a music symbol, otherwise
+ * return NO */
+
+int
+is_music_symbol(str)
+
+char *str; /* which string to check */
+
+{
+ char *string;
+ int font;
+ int size;
+
+
+ if (str == (char *) 0) {
+ return(NO);
+ }
+
+ font = str[0];
+ size = str[1];
+ string = str + 2;
+
+ /* has to be music char followed by null to be YES */
+ if (next_str_char(&string, &font, &size) == '\0') {
+ return(NO);
+ }
+ if ( ! IS_MUSIC_FONT(font)) {
+ return(NO);
+ }
+ if (next_str_char(&string, &font, &size) == '\0') {
+ return(YES);
+ }
+ return(NO);
+}
+\f
+
+/* return the ascent of a string in inches. This is the largest ascent of any
+ * character in the string */
+
+double
+strascent(str)
+
+char *str; /* which string to process */
+
+{
+ float max_ascent, a; /* tallest and current ascent */
+ char *s; /* to walk through string */
+ int font, size, code;
+ int textfont;
+ double vertical, horizontal;
+ float baseline_offset; /* to account for vertical motion */
+ int in_pile;
+ int only_mus_sym; /* YES if string consists solely
+ * of a music char */
+
+
+ if (str == (char *) 0) {
+ return(0.0);
+ }
+
+ only_mus_sym = is_music_symbol(str);
+
+ /* first 2 bytes are font and size. */
+ font = str[0];
+ size = str[1];
+
+ /* Walk through the string. */
+ for (max_ascent = 0.0, baseline_offset = 0.0, s = str + 2;
+ (code = nxt_str_char(&s, &font, &size, &textfont,
+ &vertical, &horizontal, &in_pile, NO)) > 0; ) {
+
+ /* A newline goes to following line, so we probably won't
+ * get any higher ascent than we have so far, but if
+ * user gives enough vertical motion, we might, so continue. */
+ if (code == '\n') {
+ baseline_offset -= fontheight(font, size);
+ }
+
+ /* adjust for any vertical motion */
+ if (vertical != 0.0) {
+ baseline_offset += vertical;
+ }
+
+ /* music characters inside strings get moved up to the baseline,
+ * so use their height as ascent.
+ * Regular characters use the
+ * ascent of the character */
+ if ((IS_MUSIC_FONT(font)) && (only_mus_sym == NO)) {
+ a = height(font, size, code);
+ }
+ else {
+ a = ascent(font, size, code);
+ }
+ a += baseline_offset;
+
+ /* if tallest seen save this height */
+ if (a > max_ascent) {
+ max_ascent = a;
+ }
+ }
+
+ /* if boxed, allow space for that */
+ if (IS_BOXED(str) == YES) {
+ max_ascent += 2.5 * STDPAD;
+ }
+ /* similarly, allow space for circle */
+ if (IS_CIRCLED(str) == YES) {
+ float ascent_adjust;
+ max_ascent += circled_dimensions(str, (float *) 0, (float *) 0,
+ &ascent_adjust, (float *) 0);
+ max_ascent += ascent_adjust;
+ }
+ return(max_ascent);
+}
+\f
+
+/* return the descent of a string in inches. This is the largest descent of any
+ * character in the string */
+
+double
+strdescent(str)
+
+char *str; /* which string to process */
+
+{
+ float max_descent, d; /* largest and current descent */
+ float line_descent; /* descent caused by newlines */
+ double vertical, horizontal;
+ int in_pile;
+ char *s; /* to walk through string */
+ int font, size, code;
+ int textfont;
+ int only_mus_sym; /* YES if string consists solely
+ * of a music char */
+
+
+ if (str == (char *) 0) {
+ return(0.0);
+ }
+
+ only_mus_sym = is_music_symbol(str);
+
+ /* first 2 bytes are font and size. */
+ font = str[0];
+ size = str[1];
+
+ /* walk through the string. */
+ for (max_descent = line_descent = 0.0, s = str + 2;
+ (code = nxt_str_char(&s, &font, &size, &textfont,
+ &vertical, &horizontal, &in_pile, NO)) > 0
+ || vertical != 0.0; ) {
+
+ /* Adjust for vertical motion. Since line_descent is
+ * measured downward and vertical is upward, have to
+ * substract the vertical, then adjust max_descent
+ * to compensate. */
+ if (vertical != 0.0) {
+ line_descent -= vertical;
+ max_descent += vertical;
+ if (code == 0) {
+ /* motion only */
+ continue;
+ }
+ }
+
+ if (code == '\n') {
+ /* at newline, descent goes down to next baseline,
+ * which will be down from current baseline
+ * by height of font */
+ line_descent += fontheight(font, size);
+ max_descent = 0.0;
+ continue;
+ }
+
+ /* music characters inside strings get moved up to the
+ * baseline, so have no descent. */
+ if ( ! (IS_MUSIC_FONT(font)) || (only_mus_sym == YES)) {
+ d = descent(font, size, code);
+ }
+ else {
+ d = 0.0;
+ }
+
+ /* if largest descent seen, save this descent */
+ if (d > max_descent) {
+ max_descent = d;
+ }
+ }
+
+ /* if boxed, allow space for that */
+ if (IS_BOXED(str) == YES) {
+ max_descent += 3.5 * STDPAD;
+ }
+ /* similarly, allow space for circle */
+ if (IS_CIRCLED(str) == YES) {
+ max_descent += circled_dimensions(str, (float *) 0, (float *) 0,
+ (float *) 0, (float *) 0);
+ }
+ return(max_descent + line_descent);
+}
+\f
+
+/* return the height of a string in inches. This is the maximum ascent plus the
+ * maximum descent */
+
+double
+strheight(str)
+
+char *str; /* which string to process */
+{
+ /* Since letters may not
+ * align because of ascent/descent, we get the tallest extent
+ * by adding the largest ascent to the largest descent */
+ return( strascent(str) + strdescent(str));
+}
+\f
+
+/* return the width of a string. This is the sum of the widths of the
+ * individual characters in the string */
+
+double
+strwidth(str)
+char *str;
+{
+ float tot_width;
+ float widest_line; /* for multi-line strings */
+ float curr_width;
+ double horizontal, vertical;
+ int was_in_pile; /* if in pile last time through loop */
+ int in_pile_now; /* if current character is inside a pile */
+ char *s; /* to walk through string */
+ int font, size, code;
+ int textfont;
+
+
+ if (str == (char *) 0) {
+ return(0.0);
+ }
+
+ /* first 2 bytes are font and size. */
+ font = str[0];
+ size = str[1];
+
+ /* walk through string */
+ was_in_pile = NO;
+ for (curr_width = tot_width = widest_line = 0.0, s = str + 2;
+ (code = nxt_str_char(&s, &font, &size, &textfont,
+ &vertical, &horizontal, &in_pile_now, NO)) > 0;
+ was_in_pile = in_pile_now) {
+
+ /* Piles are handled specially. As soon as we enter a pile,
+ * we call the function to get its entire width. Then for
+ * the rest of the pile, we just skip past everything */
+ if (in_pile_now == YES) {
+ if (was_in_pile == NO) {
+ curr_width += pile_width();
+ if (curr_width > tot_width) {
+ tot_width = curr_width;
+ }
+ }
+ continue;
+ }
+
+ /* the horizontal movement coming out of a pile doesn't count,
+ * since it was included in the pile, otherwise it does */
+ if (was_in_pile == NO) {
+ curr_width += horizontal;
+ }
+ if (curr_width > tot_width) {
+ tot_width = curr_width;
+ }
+
+ if (code == '\n') {
+ /* keep track of width line of multi-line string */
+ if (tot_width > widest_line) {
+ widest_line = tot_width;
+ }
+ tot_width = 0.0;
+ curr_width = 0.0;
+ continue;
+ }
+
+ if (code == '\b') {
+ /* backspace */
+ tot_width -= backsp_width(size);
+ curr_width -= backsp_width(size);
+ continue;
+ }
+
+ /* If we have the special "page number" character,
+ * or special "total number of pages" character,
+ * we deal with that here. */
+ if ( (code == '%' || code == '#') && (s > str + 3)
+ && ( (*(s-2) & 0xff) == STR_PAGENUM
+ || (*(s-2) & 0xff) == STR_NUMPAGES) ) {
+
+ char pgnumbuff[8], *pgnum_p;
+
+ /* convert page number to a string and
+ * add the width of each character in
+ * that string. */
+ (void) sprintf(pgnumbuff, "%d",
+ code == '%' ? Pagenum : Last_pagenum);
+
+ for ( pgnum_p = pgnumbuff; *pgnum_p != '\0';
+ pgnum_p++) {
+ curr_width += width(font, size, *pgnum_p);
+ }
+ }
+
+ else {
+ /* Oh good. This is a normal case. Just add
+ * width of this character to width so far */
+ curr_width += width(font, size, code);
+ }
+
+ if (curr_width > tot_width) {
+ tot_width = curr_width;
+ }
+ }
+ if (tot_width < widest_line) {
+ tot_width = widest_line;
+ }
+ /* if string is boxed, allow space for the box */
+ if (IS_BOXED(str) == YES) {
+ tot_width += 6.0 * STDPAD;
+ }
+ /* similarly, allow space for circled */
+ if (IS_CIRCLED(str) == YES) {
+ (void) circled_dimensions(str, (float *) 0, &tot_width,
+ (float *) 0, (float *) 0);
+ }
+ return(tot_width);
+}
+\f
+
+/* Return the width to the "anchor" point of a string. For most strings,
+ * this will be half the width of the first character. But for a string
+ * that begins with things piled atop one another, it is the alignment point.
+ * And for boxed or circled strings, the box or circle must be considered.
+ */
+
+double
+left_width(string)
+
+char *string;
+
+{
+ int font;
+ int size;
+ char *pile_start_p; /* where pile begins, if any */
+
+ if (starts_piled(string, &font, &size, &pile_start_p) == YES) {
+ return(align_distance(pile_start_p, font, size));
+ }
+ else {
+ int ch;
+ float extra; /* space for box or circle, if any */
+
+ /* For boxed or circled strings,
+ * the space for the box or circle must be added in */
+ if (IS_BOXED(string) == YES) {
+ extra = 3.5 * STDPAD;
+ }
+ else if (IS_CIRCLED(string) == YES) {
+ (void) circled_dimensions(string, (float *) 0,
+ (float *) 0, (float *) 0, &extra);
+ }
+ else {
+ extra = 0.0;
+ }
+
+ /* Get half the width of the first character in the string */
+ font = *string++;
+ size = *string++;
+ ch = next_str_char(&string, &font, &size);
+ return(width(font, size, ch) / 2.0 + extra);
+ }
+}
+\f
+
+/* If string begins with piled text, return YES, otherwise NO,
+ * If YES, also return via pointers the start of the pile and the
+ * font and size at that point. */
+
+static int
+starts_piled(string, font_p, size_p, pile_start_p_p)
+
+char *string;
+int *font_p;
+int *size_p;
+char **pile_start_p_p;
+
+{
+ *font_p = *string++;
+ *size_p = *string++;
+
+ /* walk through string, skipping any leading box/size/font */
+ for ( ; *string != '\0'; string++) {
+ if (IS_STR_COMMAND(*string)) {
+ switch(*string & 0xff) {
+
+ case STR_FONT:
+ *font_p = *(++string);
+ break;
+
+ case STR_SIZE:
+ *size_p = *(++string);
+ break;
+
+ case STR_BOX:
+ case STR_CIR:
+ break;
+
+ case STR_PILE:
+ /* The first thing we found that was not to be
+ * ignored is the beginning of a pile */
+ *pile_start_p_p = string;
+ return(YES);
+
+ default:
+ return(NO);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ return(NO);
+}
+\f
+
+/* given a string representing a chord mark, transpose it. For each letter
+ * 'A' to 'G' optionally followed by an accidental, call function to
+ * get transposed value. Build new string with transposed values. Free up
+ * the old string and return the new one. Also, if the accidental was
+ * of the form &, #, x, or && instead of \(smflat) etc, change to proper
+ * music symbol. Also handles translation of o, o/ and ^ to dim, halfdim,
+ * and triangle symbols, and does translation of unescaped accidentals. */
+
+char *
+tranchstr(chordstring, staffno)
+
+char *chordstring; /* untransposed string */
+int staffno; /* which staff it is associated with */
+ /* A staffno of -1 means no transpose, just translate */
+
+{
+ char tmpbuff[128]; /* temporary copy of transposed string */
+ char replacement[4]; /* for dim/halfdim/triangle */
+ short i; /* index into tmpbuff */
+ unsigned char *str; /* walk through chordstring */
+ char *transposed; /* new version of letter[accidental] */
+ char tranbuff[4]; /* to point 'transposed' at if not really
+ * transposing */
+ char letter; /* A to G */
+ char accidental;
+ int escaped; /* YES is accidental was escaped */
+ char literal_accidental; /* what would normally be translated */
+ int nprocessed; /* how many character processed by subroutine */
+ char *newstring; /* final copy of transposed string */
+ int n;
+ int size;
+ int in_pile; /* YES if inside a pile */
+ int acc_size; /* size for accidentals */
+
+
+ /* get font/size info */
+ tmpbuff[0] = chordstring[0];
+ tmpbuff[1] = chordstring[1];
+ size = chordstring[1];
+ in_pile = NO;
+ str = (unsigned char *) (chordstring + 2);
+ literal_accidental = '\0'; /* avoids bogus "used before set" warning */
+
+ /* walk through original string */
+ for (i = 2; *str != '\0'; str++) {
+
+ /* Be safe. Bail out a little before we reach end,
+ * because some things take several bytes,
+ * and it's easiest to just check once per loop. */
+ if (i > sizeof(tmpbuff) - 8) {
+ ufatal("chord string too long: '%s'", chordstring + 2);
+ }
+
+ acc_size = accsize(size);
+
+ /* If a STR_*, deal with that */
+ if ((n = str_cmd((char *) str, &size, &in_pile)) > 0) {
+ strncpy(tmpbuff + i, (char *) str, (unsigned) n);
+ i += n;
+ str += n - 1;
+ }
+
+ /* handle backslashed o and ^ */
+ else if (*str == '\\' && ( *(str+1) == 'o' || *(str+1) == '^' ) ) {
+ str++;
+ tmpbuff[i++] = *str;
+ }
+
+ else if (*str >= 'A' && *str <= 'G') {
+
+ /* Aha! Something to transpose. */
+ letter = *str;
+
+ str += get_accidental( (unsigned char *) (str + 1),
+ &accidental, &acc_size, NO, &escaped);
+ if (escaped == YES) {
+ /* not *really* an accidental, so save to
+ * print later. */
+ literal_accidental = accidental;
+ accidental = '\0';
+ }
+ if (staffno == -1) {
+ /* not to be transposed, so make a string
+ * that would be like what tranchnote() would
+ * return, but with no transposition. */
+ tranbuff[0] = letter;
+ tranbuff[1] = accidental;
+ tranbuff[2] = '\0';
+ transposed = tranbuff;
+ }
+ else {
+ /* get the transposed value */
+ transposed = tranchnote(letter, accidental, staffno);
+ }
+
+ /* put transposed letter into output */
+ tmpbuff[i++] = *transposed;
+
+ /* now add accidental if any */
+ i += add_accidental(tmpbuff + i, (int) *++transposed,
+ acc_size, NO);
+
+ /* add on any escaped pseudo-accidental */
+ if (escaped == YES) {
+ i += add_accidental(tmpbuff + i,
+ (int) literal_accidental,
+ acc_size, YES);
+ escaped = NO;
+ }
+
+ /* handle dim/halfdim/triangle transformations */
+ if ((n = dim_tri(str + 1, replacement, size, YES)) > 0) {
+ strcpy(tmpbuff + i, replacement);
+ i += strlen(replacement);
+ str += n;
+ }
+ }
+ else {
+ /* Originally we only translated things like # and &
+ * in chords to musical accidental symbols if they
+ * immediately followed a letter A-G. But due to
+ * popular demand, they are now translated everywhere,
+ * unless escaped. */
+ nprocessed = get_accidental( (unsigned char *) str,
+ &accidental, &acc_size, NO, &escaped);
+ if (nprocessed > 0) {
+ i += add_accidental(tmpbuff + i,
+ (int) accidental,
+ acc_size, escaped);
+ /* the -1 is because str will get incremented
+ * at the top of the 'for' */
+ str += nprocessed - 1;
+ }
+ else {
+ /* something boring. Just copy */
+ tmpbuff[i++] = *str;
+ }
+ }
+ }
+
+ /* need to make permanent copy of new string */
+ tmpbuff[i++] = '\0';
+ MALLOCA(char, newstring, i + 1);
+ (void) memcpy(newstring, tmpbuff, (unsigned) i);
+
+ /* free original version */
+ FREE(chordstring);
+
+ /* return new, transposed version */
+ return(newstring);
+}
+\f
+
+/* If there is a STR_* command in chord/analysis/figbass, return how
+ * many characters long it is. Also update the size if the
+ * command was one to change size, and update pile status if necessary. */
+
+static int
+str_cmd(str, size_p, in_pile_p)
+
+char *str; /* check string starting here */
+int *size_p;
+int *in_pile_p; /* YES if in pile, may be updated */
+
+{
+ if (IS_STR_COMMAND(*str)) {
+ switch(*str & 0xff) {
+
+ case STR_SIZE:
+ /* update size */
+ *size_p = *(str + 1);
+ /* command plus 1 argument byte */
+ return(2);
+
+ case STR_PAGENUM:
+ case STR_NUMPAGES:
+ case STR_FONT:
+ case STR_BACKSPACE:
+ case STR_VERTICAL:
+ /* command plus 1 argument byte */
+ return(2);
+
+ case STR_MUS_CHAR:
+ /* command plus 2 argument bytes */
+ return(3);
+
+ case STR_PILE:
+ /* entering/leaving a pile alters the size */
+ *size_p = pile_size(*size_p, *in_pile_p);
+ *in_pile_p = (*in_pile_p ? NO : YES);
+ break;
+
+ default:
+ /* others have no argument bytes */
+ return(1);
+ }
+ }
+ return(0);
+}
+\f
+
+/* Check the first character of the given string to see if it is an accidental
+ * or something that should be translated to an accidental (# & x && and
+ * maybe n). If so, fill in the accidental. If the accidental was specified
+ * via a STR_MUS_CHAR, also update the accidental size.
+ * If no accidental, accidental_p will will filled in
+ * with '\0'. In any case return how many bytes were processed.
+ */
+
+static int
+get_accidental(string, accidental_p, acc_size_p, trans_natural, escaped_p)
+
+unsigned char *string; /* check this for an accidental */
+char *accidental_p; /* return the accidental here, or \0 if none */
+int *acc_size_p; /* return the accidental size here */
+int trans_natural; /* if YES, translate n to natural, else leave as n */
+int *escaped_p; /* Return value: YES if the symbol was backslashed */
+
+{
+ unsigned char *str_p;
+
+ str_p = string;
+
+ /* assume no accidental */
+ *accidental_p = '\0';
+
+ /* check if escaped */
+ if (*str_p == '\\') {
+ *escaped_p = YES;
+ str_p++;
+ }
+ else {
+ *escaped_p = NO;
+ }
+
+ /* See if the following character is an accidental */
+ switch (*str_p) {
+
+ case '#':
+ case 'x':
+ *accidental_p = *str_p++;
+ break;
+ case '&':
+ *accidental_p = *str_p++;
+ /* have to peek ahead to check for double flat,
+ * but not if escaped, so person can get a literal
+ * ampersand followed by a flat. */
+ if (*escaped_p == NO && *str_p == '&') {
+ /* double flat is 'B' internally */
+ *accidental_p = 'B';
+ str_p++;
+ }
+ break;
+
+ case 'n':
+ /* naturals are not translated in chords, but are
+ * in analysis and figbass */
+ if (trans_natural == YES) {
+ *accidental_p = *str_p++;
+ }
+ break;
+
+ case STR_MUS_CHAR:
+ if (*escaped_p == YES) {
+ break;
+ }
+ /* Check if user put in \(flat) or something
+ * similar. If so, use that. */
+ switch (*(str_p + 2)) {
+ case C_FLAT:
+ *acc_size_p = *(str_p + 1);
+ *accidental_p = '&';
+ str_p += 3;
+ break;
+
+ case C_SHARP:
+ *acc_size_p = *(str_p + 1);
+ *accidental_p = '#';
+ str_p += 3;
+ break;
+
+ case C_DBLFLAT:
+ *acc_size_p = *(str_p + 1);
+ *accidental_p = 'B';
+ str_p += 3;
+ break;
+
+ case C_DBLSHARP:
+ *acc_size_p = *(str_p + 1);
+ *accidental_p = 'x';
+ str_p += 3;
+ break;
+
+ case C_NAT:
+ /* Always translate the natural symbol,
+ * even when trans_natural is NO. That really
+ * applies just to the use of 'n' which is
+ * likely to be wanted as a real n, whereas
+ * a music symbol natural is unambiguous. */
+ *acc_size_p = *(str_p + 1);
+ *accidental_p = 'n';
+ str_p += 3;
+ break;
+
+ default:
+ /* false alarm. Some other
+ * music character. */
+ break;
+ }
+ break;
+
+ default:
+ /* nothing special */
+ break;
+ }
+
+ /* If all we saw was a backslash,
+ * then there wasn't really an accidental */
+ if (*escaped_p == YES && str_p == string + 1) {
+ *escaped_p = NO;
+ str_p = string;
+ }
+
+ return(str_p - string);
+}
+\f
+
+/* Write the given accidental in the given size to the given string.
+ * Return how many bytes were added. */
+
+static int
+add_accidental(buff, acc_character, acc_size, escaped)
+
+char *buff; /* write into this buffer */
+int acc_character; /* write this accidental */
+int acc_size; /* make accidental this big */
+int escaped; /* if YES, was escaped, so not really an accidental;
+ * print it as a normal character */
+
+{
+ if (acc_character != '\0') {
+
+ /* if escaped, just treat like normal character. */
+ if (escaped == YES) {
+ buff[0] = acc_character;
+ return(1);
+ }
+
+ /* sharps and naturals are tall enough that they can
+ * make things not line up, so move them down some */
+ if (acc_character == '#' || acc_character == 'n') {
+ buff[0] = (char) STR_VERTICAL;
+ buff[1] = (char) ENCODE_VERT(-4);
+ buff += 2;
+ }
+ /* has accidental. Add STR_MUS_CHAR-size-code */
+ buff[0] = (char) STR_MUS_CHAR;
+
+ /* double sharp is special. It is too small,
+ * so make it bigger */
+ if (acc_character == 'x') {
+ acc_size = (int) ( (float) acc_size
+ * 1.25);
+ }
+ buff[1] = (char) acc_size;
+
+ /* use accidental of appropriate type */
+ switch (acc_character) {
+
+ case '#':
+ buff[2] = C_SHARP;
+ break;
+
+ case '&':
+ buff[2] = C_FLAT;
+ break;
+
+ case 'x':
+ buff[2] = C_DBLSHARP;
+ break;
+
+ case 'B':
+ buff[2] = C_DBLFLAT;
+ break;
+
+ case 'n':
+ buff[2] = C_NAT;
+ break;
+
+ default:
+ pfatal("illegal accidental on transposed chord");
+ break;
+ }
+ if (acc_character == '#' || acc_character == 'n') {
+ buff[3] = (char) STR_VERTICAL;
+ buff[4] = (char) ENCODE_VERT(4);
+ /* We added 3 bytes for the accidental, plus
+ * 2 bytes before and after for vertical motion. */
+ return(7);
+ }
+ else {
+ return(3); /* we added 3 bytes */
+ }
+ }
+
+ return (0);
+}
+\f
+
+/* In chords and such, "o" becomes \(dim), "o/" becomes \(halfdim)
+ * unless followed by [A-G] in which case it becomes "\(dim)/",
+ * and "^" becomes \(triangle). Return number of characters processed.
+ */
+
+static int
+dim_tri(str_p, replacement, size, is_chord)
+
+unsigned char *str_p; /* check string at this point */
+char *replacement; /* return the replacement in this buffer,
+ * which needs to be at least 4 bytes long */
+int size; /* use this size for music character */
+int is_chord; /* YES for chord, NO for analysis/figbass */
+
+{
+ if (*str_p == '^') {
+ replacement[0] = (char) STR_MUS_CHAR;
+ replacement[1] = size;
+ replacement[2] = C_TRIANGLE;
+ replacement[3] = '\0';
+ return(1);
+ }
+ else if (*str_p == 'o') {
+ replacement[0] = (char) STR_MUS_CHAR;
+ replacement[1] = size;
+ replacement[3] = '\0';
+ if ( *(str_p+1) == '/' && (is_chord == NO ||
+ (*(str_p+2) < 'A' || *(str_p+2) > 'G'))) {
+ replacement[2] = C_HALFDIM;
+ return(2);
+ }
+ else {
+ replacement[2] = C_DIM;
+ return(1);
+ }
+ }
+ return(0);
+}
+\f
+
+/* Given a string for analysis or figbass, transform the accidentals
+ * & # && x n to their music characters.
+ */
+
+char *
+acc_trans(string)
+
+char *string;
+
+{
+ char buffer[128]; /* output buffer for transformed string */
+ char *out_p; /* current location in output buffer */
+ char replacement[4]; /* space for dim, halfdim, etc */
+ int n;
+ int size, acc_size;
+ char accidental; /* #, &, x, etc */
+ int escaped; /* YES is accidental was escaped */
+ int in_pile; /* YES if inside a pile */
+
+
+ buffer[0] = string[0];
+ buffer[1] = string[1];
+ size = string[1];
+ in_pile = NO;
+
+ /* walk through string, transforming any accidentals along the way */
+ for ( string += 2, out_p = buffer + 2; *string != '\0'; ) {
+ /* Be safe. Bail out a little before we reach end,
+ * because some things take several bytes,
+ * and it's easiest to just check once per loop. */
+ if (out_p - buffer > sizeof(buffer) - 8) {
+ l_ufatal(Curr_filename, yylineno,
+ "analysis or figbass string too long");
+ }
+
+ acc_size = accsize(size);
+ if ((n = get_accidental((unsigned char *) string,
+ &accidental, &acc_size, YES, &escaped)) > 0 ) {
+ out_p += add_accidental(out_p, (int) accidental,
+ acc_size, escaped);
+ string += n;
+ }
+ else if (*string == '\\' && ( *(string+1) == 'o' || *(string+1) == '^') ) {
+ *out_p++ = *++string;
+ string++;
+ }
+ else if ((n = dim_tri((unsigned char *) string, replacement,
+ size, NO)) > 0) {
+ strcpy(out_p, replacement);
+ out_p += strlen(replacement);
+ string += n;
+ }
+ else if ((n = str_cmd(string, &size, &in_pile)) > 0) {
+ strncpy(out_p, string, (unsigned) n);
+ out_p += n;
+ string += n;
+ }
+ else {
+ *out_p++ = *string++;
+ }
+ }
+ *out_p = '\0';
+
+ return(copy_string(buffer + 2, buffer[0], buffer[1]));
+}
+\f
+/* Given a chord, analysis or figbass string,
+ * transform according to their special rules:
+ * - : gets translated to \: and vice-versa
+ * - figbass starts in piled mode
+ * - in figbass, a / gets translated to \/ and vice-versa
+ * This string will be in half transformed state: the first 2 bytes
+ * are font/size, but the rest is still all ASCII, not internal format.
+ */
+
+char *
+modify_chstr(string, modifier)
+
+char *string;
+int modifier;
+
+{
+ int length; /* of modified string */
+ char *s; /* walk through string */
+ char *newstring;
+ char *new_p; /* walk through newstring */
+ int need_new; /* if we need to make a new string */
+
+
+ length = strlen(string);
+ if (modifier == TM_FIGBASS) {
+ /* We'll need two extra bytes for
+ * the leading \: for pile mode. */
+ length += 2;
+ need_new = YES;
+ }
+ else {
+ /* Only need a new string if the original has colons,
+ * so assume for now we won't need a new string */
+ need_new = NO;
+ }
+
+ /* Figure out how much space we'll need for the modified string.
+ * Any unbackslashed colons will take up an extra byte once
+ * we backslash it. But any backslashed one will take up one
+ * less when we unescape it. Similar for slashes in figbass. */
+ for (s = string + 2; *s != '\0'; s++) {
+ if (*s == ':') {
+ length++;
+ need_new = YES;
+ }
+ else if (modifier == TM_FIGBASS && *s == '/') {
+ /* o/ means half diminished so that doesn't count */
+ if (s > string + 2 && *(s-1) == 'o') {
+ continue;
+ }
+ length++;
+ need_new = YES;
+ }
+ else if (*s == '\\') {
+ s++;
+ /* things that occur inside \(...) don't count */
+ if (*s == '(') {
+ for (s++; *s != '\0' && *s != ')'; s++) {
+ ;
+ }
+ /* If no closing parenthesis, return as is;
+ * later code will catch that */
+ if (*s == '\0') {
+ return(string);
+ }
+ }
+ else if (*s == ':') {
+ length--;
+ need_new = YES;
+ }
+ else if (modifier == TM_FIGBASS && *s == '/') {
+ length--;
+ need_new = YES;
+ }
+ }
+ }
+
+ /* If string is okay as is, we are done here */
+ if (need_new == NO) {
+ return(string);
+ }
+
+ /* get enough space for new string */
+ MALLOCA(char, newstring, length + 1);
+
+ /* copy font/size */
+ newstring[0] = string[0];
+ newstring[1] = string[1];
+
+ new_p = newstring + 2;
+ s = string + 2;
+ if (modifier == TM_FIGBASS) {
+ /* add \: but after box, if any */
+ if (string[2] == '\\' && string[3] == '[') {
+ *new_p++ = *s++;
+ *new_p++ = *s++;
+ }
+ *new_p++ = '\\';
+ *new_p++ = ':';
+ }
+
+ /* walk through rest of string, copying, but transforming
+ * any slashes and colons along the way */
+ for ( ; *s != '\0'; s++, new_p++) {
+
+ /* handle colons */
+ if (*s == ':') {
+ /* add a backslash */
+ *new_p++ = '\\';
+ }
+ else if (*s == '\\' && *(s+1) == ':') {
+ /* skip past the backslash */
+ s++;
+ }
+
+ /* handle slashes in figbass */
+ else if (modifier == TM_FIGBASS) {
+ if (*s == '/') {
+ /* o/ means half diminished
+ * so that doesn't count */
+ if (s <= string + 2 || *(s-1) != 'o') {
+ /* add a backslash */
+ *new_p++ = '\\';
+ }
+ }
+ else if (*s == '\\' && *(s+1) == '/') {
+ /* skip past the backslash */
+ s++;
+ }
+ }
+
+ /* copy from original string to new one */
+ *new_p = *s;
+ }
+
+ /* original is now no longer needed */
+ FREE(string);
+
+ /* terminate and return the modified string */
+ *new_p = '\0';
+ return(newstring);
+}
+\f
+
+/* given an integer point size, return the integer point size appropriate
+ * for a "small" version. This is SM_FACTOR times the size, rounded, but
+ * not less than 1. */
+
+static int
+smallsize(size)
+
+int size;
+
+{
+ size = (int) ( (float) size * SM_FACTOR);
+ if (size < 1) {
+ size = 1;
+ }
+ return(size);
+}
+\f
+
+/* accidentals in chords need to be scaled. Given a size, return the size
+ * that an accidental should be. This is 60% of given size, rounded to
+ * an integer, but no smaller than 1. */
+
+static int
+accsize(size)
+
+int size;
+
+{
+ size = (int) ( (float) size * 0.6);
+ if (size < 1) {
+ size = 1;
+ }
+ return(size);
+}
+\f
+
+/* return which character to use for rest, based on basictime */
+
+int
+restchar(basictime)
+
+int basictime;
+
+{
+ if (basictime < -1) {
+ pfatal("tried to get rest character for multirest");
+ /*NOTREACHED*/
+ return(0);
+ }
+
+ else if (basictime == -1) {
+ /* quad rest */
+ return (C_QWHREST);
+ }
+
+ else if (basictime == 0) {
+ /* double whole rest */
+ return (C_DWHREST);
+ }
+
+ else {
+ /* other non-multirest */
+ return (Resttab [ drmo(basictime) ] );
+ }
+}
+\f
+
+/* return YES if given font is an italic font (includes boldital too) */
+
+int
+is_ital_font(font)
+
+int font;
+
+{
+ return(Fontinfo[ font_index(font) ].is_ital);
+}
+\f
+
+/* given a string, return, via pointers the font and size in effect at the
+ * end of the string */
+
+void
+end_fontsize(str, font_p, size_p)
+
+char *str; /* check this string */
+int *font_p; /* return font at end of str via this pointer */
+int *size_p; /* return size at end of str via this pointer */
+
+{
+ if (str == (char *) 0) {
+ /* empty string, use defaults */
+ *font_p = FONT_TR;
+ *size_p = DFLT_SIZE;
+ return;
+ }
+
+ /* find the font/size in effect at end of given string */
+ *font_p = *str++;
+ *size_p = *str++;
+ while (next_str_char(&str, font_p, size_p) != '\0') {
+ ;
+ }
+}
+\f
+
+/* given a string, return a string made up of a dash in the font and size
+ * of the end of the given string. However, if the string ends with a ~ or _
+ * return a string containing that instead */
+
+char *
+dashstr(str)
+
+char *str; /* return dash with same font/size as end of this string */
+
+{
+ int font, size;
+ char *newstring;
+ int ch; /* character to use */
+
+
+ end_fontsize(str, &font, &size);
+ ch = last_char(str);
+ if (ch != '~' && ch != '_') {
+ ch = '-';
+ }
+
+ /* allocate space for dash string and fill it in */
+ MALLOCA(char, newstring, 4);
+ newstring[0] = (char) font;
+ newstring[1] = (char) size;
+ newstring[2] = (char) ch;
+ newstring[3] = '\0';
+ return(newstring);
+}
+\f
+
+/* Given an internal format string, create an ASCII-only string. Flags
+ * tell how complete a conversion to do. If verbose is YES, try to convert
+ * everything back to user's original input, otherwise ignore special things
+ * other than music characters, extended characters, and backspace.
+ * If pagenum is YES, interpolate the current page number rather than using %.
+ *
+ * Recreating the original user string is not perfect, but is usually right.
+ * Where there are shortcuts, we can't tell if user used them or not.
+ * Extended characters are output by name even if user put them in as single
+ * Latin-1 characters. But we couldn't use the Latin-1 hyper-ASCII in midi
+ * anyway, because they have high bit set.
+ *
+ * Returns the ASCII-ized string, which is stored in an area that will get
+ * overwritten on subsequent calls, so if caller needs a permanent copy,
+ * they have to make it themselves.
+ */
+
+/* This is how much to malloc at a time to hold the ASCII-ized string */
+#define ASCII_BSIZE 512
+
+char *
+ascii_str(string, verbose, pagenum, textmod)
+
+char *string; /* internal format string to convert */
+int verbose; /* If YES, try to reproduce user's original input */
+int pagenum; /* YES (interpolate number for \%) or NO (leave \% as is) */
+int textmod; /* TM_ value */
+
+{
+ static char *buff = 0; /* for ASCII-ized string */
+ static unsigned buff_length = 0;/* how much is malloc-ed */
+ int i; /* index into ASCII-ized string */
+ char *musname; /* music character name */
+ int in_pile = NO;
+ char *str; /* walk through string */
+ int musfont; /* FONT_MUSIC* */
+
+
+ /* first time, get some space */
+ if (buff_length == 0) {
+ buff_length = ASCII_BSIZE;
+ MALLOCA(char, buff, buff_length);
+ }
+
+ /* walk through string */
+ i = 0;
+ /* special case: normally we implicitly begin a figbass with a
+ * pile start, but if users cancels that, it won't be there */
+ if (textmod == TM_FIGBASS &&
+ (((unsigned char) *(string+2)) & 0xff) != STR_PILE) {
+ buff[i++] = ':';
+ }
+ for (str = string + 2; *str != '\0'; str++) {
+ switch ( ((unsigned char) *str) & 0xff) {
+
+ case STR_FONT:
+ str++;
+#ifdef EXTCHAR
+ if ( (int) *str > EXT_FONT_OFFSET) {
+ str++;
+ /* translate to Mup name */
+ (void) sprintf(buff + i, "\\(%s)",
+ ext_num2name((int) *str));
+ while (buff[i] != '\0') {
+ i++;
+ }
+ /* skip past the return to original font */
+ str += 2;
+ }
+ else if (verbose == YES) {
+#else
+ if (verbose == YES) {
+#endif
+ (void) sprintf(buff + i, "\\f(%s)",
+ fontnum2name((int) *str));
+ while (buff[i] != '\0') {
+ i++;
+ }
+ }
+ break;
+
+ case STR_SIZE:
+ str++;
+ if (verbose == YES) {
+ (void) sprintf(buff + i, "\\s(%d)", (int) *str);
+ while (buff[i] != '\0') {
+ i++;
+ }
+ }
+ break;
+
+ case STR_VERTICAL:
+ str++;
+ if (verbose == YES) {
+ (void) sprintf(buff + i, "\\v(%d)",
+ DECODE_VERT((int) *str) * 100
+ / MAXVERTICAL);
+ while (buff[i] != '\0') {
+ i++;
+ }
+ }
+ break;
+
+ case STR_MUS_CHAR:
+ case STR_MUS_CHAR2:
+ musfont = str2mfont( ((unsigned char) *str) & 0xff);
+
+ /* skip past the size byte,
+ * and on to the character code. */
+ str += 2;
+ /* In chordlike stuffs, we translate things like
+ * # and &&, so translate them back. It's possible
+ * the user used the names explicitly rather than us
+ * translating, in which case this won't be
+ * strictly what they put in, but it will be
+ * consistent, so that a caller of this function
+ * can easily sort or compare values
+ * without having to know (for example)
+ * that '#' and \(smsharp) are the same thing. */
+ musname = 0;
+ if (IS_CHORDLIKE(textmod) == YES
+ && musfont == FONT_MUSIC) {
+ switch( ((unsigned char) *str) & 0xff) {
+ case C_SHARP:
+ musname = "#";
+ break;
+ case C_FLAT:
+ musname = "&";
+ break;
+ case C_DBLSHARP:
+ musname = "x";
+ break;
+ case C_DBLFLAT:
+ musname = "&&";
+ break;
+ case C_NAT:
+ if (textmod != TM_CHORD) {
+ musname = "n";
+ }
+ break;
+ case C_DIM:
+ musname = "o";
+ break;
+ case C_HALFDIM:
+ musname = "o/";
+ break;
+ case C_TRIANGLE:
+ musname = "^";
+ break;
+ default:
+ break;
+ }
+ }
+ if (musname != 0) {
+ (void) sprintf(buff + i, musname);
+ }
+ else {
+ (void) sprintf(buff + i, "\\(%s)",
+ mc_num2name((int) *str, musfont));
+ }
+ while (buff[i] != '\0') {
+ i++;
+ }
+
+ break;
+
+ case STR_BACKSPACE:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = 'b';
+ }
+ /* ignore this and following char */
+ str++;
+ break;
+
+ case STR_PRE:
+ case STR_PST:
+ if (verbose == YES) {
+ buff[i++] = '<';
+ }
+ break;
+
+ case STR_U_PRE:
+ case STR_U_PST:
+ if (verbose == YES) {
+ buff[i++] = '<';
+ buff[i++] = '^';
+ }
+ break;
+
+ case STR_PRE_END:
+ case STR_PST_END:
+ if (verbose == YES) {
+ buff[i++] = '>';
+ }
+ break;
+
+ case STR_BOX:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = '[';
+ }
+ break;
+
+ case STR_BOX_END:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = ']';
+ }
+ break;
+
+ case STR_CIR:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = '{';
+ }
+ break;
+
+ case STR_CIR_END:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = '}';
+ }
+ break;
+
+ case STR_C_ALIGN:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = '^';
+ }
+ break;
+
+ case STR_L_ALIGN:
+ if (verbose == YES) {
+ buff[i++] = '\\';
+ buff[i++] = '|';
+ }
+ break;
+
+ case STR_PILE:
+ if (verbose == YES) {
+ /* On figbass, we implictly add a pile start */
+ if (textmod == TM_FIGBASS && string + 2 == str) {
+ ;
+ }
+ /* if this is at the end of a padded string,
+ * there is a high probability it is one
+ * we added implicitly, so skip it */
+ else if (in_pile == YES && *(str+1) == ' ' &&
+ *(str+2) == '\0') {
+ ;
+ }
+ else {
+ /* in chordlike things, user didn't
+ * use a backslash, else they did */
+ if (IS_CHORDLIKE(textmod) == NO) {
+ buff[i++] = '\\';
+ }
+ buff[i++] = ':';
+ }
+ }
+ /* keep track of toggle state */
+ in_pile = (in_pile == YES ? NO : YES);
+ break;
+
+ case STR_SLASH:
+ if (verbose == YES && textmod != TM_FIGBASS) {
+ buff[i++] = '\\';
+ }
+ buff[i++] = '/';
+ break;
+
+ case STR_PAGENUM:
+ case STR_NUMPAGES:
+ if (pagenum == YES) {
+ /* Write page number and update length.
+ * Actually, we don't have the correct values
+ * for this until late in program execution,
+ * and for MIDI, there are no pages at all,
+ * and this can be called from MIDI, so
+ * this is probably not really very useful,
+ * but this is the best we can do... */
+ (void) sprintf(buff + i, "%d",
+ (((unsigned char) *str) & 0xff)
+ == STR_PAGENUM ?
+ Pagenum : Last_pagenum);
+ while (buff[i] != '\0') {
+ i++;
+ }
+ }
+ else {
+ buff[i++] = '\\';
+ buff[i++] = *(str+1);
+ }
+ str++;
+ break;
+
+ case '\\':
+ buff[i++] = '\\';
+ buff[i++] = '\\';
+ break;
+
+ default:
+ if (*str == '\n') {
+ if (in_pile == YES) {
+ if ( *(str+1) != '\0') {
+ buff[i++] = ' ';
+ }
+ }
+ else {
+ buff[i++] = '\\';
+ buff[i++] = 'n';
+ }
+ }
+ else if (IS_CHORDLIKE(textmod) == YES && *str == ':') {
+ buff[i++] = '\\';
+ buff[i++] = ':';
+ }
+ else if (textmod == TM_FIGBASS && *str == '/') {
+ buff[i++] = '\\';
+ buff[i++] = '/';
+ }
+ else if (*str == ' ' && *(str+1) == '\0') {
+ /* This is probably a space padding
+ * that we added implicitly,
+ * so don't print it. If this is
+ * called on a 'with' item or 'print' item
+ * where user explicitly added a space,
+ * this will strip that off, which, strictly
+ * speaking, it shouldn't. But that would
+ * only be for debugging anyway, and a
+ * strange case, so don't worry about it. */
+ ;
+ }
+ else {
+ /* ordinary character */
+ buff[i++] = *str;
+ }
+ }
+
+ /* If running low on space, get some more. Could probably
+ * just truncate, since this is used for things like error
+ * messages, but alloc-ing more is easy enough. */
+ if (i > buff_length - 20) {
+ buff_length += ASCII_BSIZE;
+ REALLOCA(char, buff, buff_length);
+ }
+ }
+ buff[i++] = '\0';
+
+ return(buff);
+}
+\f
+
+/*
+ * Given a text string and a maximum desired width, try adding newlines at
+ * white space to bring the width down under the desired width. If that's
+ * not possible, do the best we can. Return pointer to the possibly
+ * altered string.
+ */
+
+char *
+split_string(string, desired_width)
+
+char *string;
+double desired_width;
+
+{
+ char *last_white_p; /* where last white space was */
+ char *curr_white_p; /* white space we're dealing with now */
+ char *str; /* to walk through string */
+ double proposed_width; /* width of string so far */
+ int font, size;
+ int c; /* the current character in string */
+ int save_c; /* temporary copy of c */
+ int save_str; /* temporary copy of character from string */
+
+
+ /* Piles are incompatible with newlines, so we don't want to
+ * even attempt to split a string with a pile in it. */
+ for (str = string + 2; *str != '\0'; str++) {
+ if ((*str & 0xff) == STR_PILE) {
+ /* string has a pile, so return it as is */
+ return(string);
+ }
+ }
+
+ /* Go through the string, until we hit white space. */
+ last_white_p = (char *) 0;
+ font = string[0];
+ size = string[1];
+ str = string + 2;
+ while ((c = next_str_char(&str, &font, &size)) != '\0') {
+
+ /* Are we at white space? */
+ if ( ! IS_MUSIC_FONT(font) && (c == ' ' || c == '\t')) {
+
+ /* Temporarily replace with newline, and terminate
+ * to get width so far if we were to add a newline */
+ curr_white_p = str - 1;
+ save_c = c;
+ save_str = *str;
+ *curr_white_p = '\n';
+ *str = '\0';
+ proposed_width = strwidth(string);
+ *curr_white_p = save_c;
+ *str = save_str;
+
+ if (proposed_width > desired_width) {
+ if (last_white_p != (char *) 0) {
+ /* reduce the width of the string by
+ * changing the most recent white space
+ * to a newline */
+ *last_white_p = '\n';
+
+ /* if the overall string is now short
+ * enough, we are done */
+ if (strwidth(string) <= desired_width) {
+ return(string);
+ }
+ last_white_p = curr_white_p;
+ }
+ else {
+ /* No previous white space, so we
+ * can't make it short enough. So change
+ * this current white space to a
+ * newline, since that's the best we
+ * can do. But also set the desired
+ * width to our current width,
+ * because we know we're
+ * going to have to be at least this
+ * wide anyway, so we might as well use
+ * this much space on future lines */
+ *curr_white_p = '\n';
+ desired_width = proposed_width;
+
+ /* no longer have a previous
+ * white space on the current line,
+ * because we just started a new
+ * line */
+ last_white_p = (char *) 0;
+ }
+
+ }
+ else {
+ /* not too wide yet. Remember where this white
+ * space is, in case the next word makes us
+ * too wide and we have to change it to a
+ * newline */
+ last_white_p = curr_white_p;
+ }
+ }
+ }
+
+ /* If last word went over the edge, move to next line if possible. */
+ if (strwidth(string) > desired_width && last_white_p != (char *) 0) {
+ *last_white_p = '\n';
+ }
+
+ /* Return the (possibly altered) string */
+ return(string);
+}
+\f
+
+/* Given a point size and an adjustment factor, return a new point size.
+ * If size would be less than MINSIZE, return MINSIZE.
+ * If it would be greater than MAXSIZE, print error and return MAXSIZE.
+ * Since we only use integer sizes, there may be some roundoff error.
+ * While it would be possible to dream up a pathological case
+ * where this roundout might be big enough to notice,
+ * for any sane scenario you would probably need
+ * an extremely high resolution printer and a microscope to notice.
+ */
+
+int
+adj_size(size, scale_factor, filename, lineno)
+
+int size; /* original point size */
+double scale_factor; /* multiply original size by this factor */
+char *filename; /* filename and lineno are for error messages */
+int lineno;
+
+{
+ size = (int) ((double) size * scale_factor + 0.5);
+ if (size < MINSIZE) {
+ return(MINSIZE);
+ }
+ if (size > MAXSIZE) {
+ l_warning(filename, lineno,
+ "Adjusted size of string would be bigger than %d", MAXSIZE);
+ return(MAXSIZE);
+ }
+ return(size);
+}
+\f
+
+/* Given a string that is in internal format, and a scale factor by which to
+ * resize that string, adjust all size bytes in the string.
+ */
+
+char *
+resize_string(string, scale_factor, filename, lineno)
+
+char *string; /* this is the string to adjust */
+double scale_factor; /* adjust sizes in string by this factor */
+char *filename; /* for error messages */
+int lineno; /* for error messages */
+
+{
+ char *s; /* to walk through string */
+
+
+ /* if string is empty, nothing to do */
+ if (string == (char *) 0 || *string == '\0') {
+ return(string);
+ }
+
+ /* if factor is sufficiently close to 1.0 that it's very clear
+ * we won't be making any changes (since we only use integer
+ * point sizes), don't bother */
+ if ( fabs( (double) (scale_factor - 1.0)) < 0.01) {
+ return(string);
+ }
+
+ /* second byte is size byte, so adjust that */
+ string[1] = (char) adj_size( (int) string[1], scale_factor,
+ filename, lineno);
+
+ /* Go through the string. For each size byte, replace it with an
+ * adjusted size. Size bytes occur immediately after STR_SIZE
+ * and STR_MUS_CHAR commands. Everything else can get copied as
+ * is: STR_BACKSPACE is in terms of the default size, so it is
+ * unaffected by this resizing, and the other special string commands
+ * are unrelated to size and thus unaffected. */
+ for (s = string + 2; *s != '\0'; s++) {
+ switch ( (unsigned char) *s ) {
+ case STR_SIZE:
+ case STR_MUS_CHAR:
+ s++;
+ *s = (char) adj_size( (int) *s, scale_factor,
+ filename, lineno);
+ break;
+ default:
+ break;
+ }
+ }
+
+ return(string);
+}
+\f
+
+/* Given a circled string, return how much to add to its ascent and
+ * descent to give room for the circle. If pointer arguments are non-zero,
+ * return additional values via those pointers.
+ */
+
+double
+circled_dimensions(str, height_p, width_p, ascent_adjust, x_offset_p)
+
+char *str; /* a circled string */
+float *height_p; /* if non-zero, return circled height here */
+float *width_p; /* if non-zero, return circled width here */
+float *ascent_adjust; /* if non-zero, return amount we added to
+ * ascent to bring up to minimum height */
+float *x_offset_p; /* if non-zero, return where to print the
+ * actual string relative to circle edge */
+
+{
+ int font, size;
+ float min_height;
+ float adjust; /* amount to bring up to min height */
+ float uncirc_height, uncirc_width;/* dimensions of uncircled str */
+ float circ_height; /* height including circle */
+ float circ_width; /* width including circle */
+ float circ_extra; /* how much to add to top and
+ * bottom to allow space for circle */
+
+
+ /* temporarily make the string uncircled */
+ size = str[2] = str[1];
+ font = str[1] = str[0];
+ /* Note that there is at least one circumstance (in split_string())
+ * where a circled string is temporarily lacking the trailing END_CIR,
+ * and strheight and strwidth don't need it, so we don't need
+ * to blank that out. */
+
+ /* get the dimensions of the uncircled version */
+ uncirc_height = strheight(str+1);
+ uncirc_width = strwidth(str+1);
+
+ /* put the circle back */
+ str[1] = str[2];
+ str[2] = (char) STR_CIR;
+
+ /* If string is unusually short vertically, treat as at least as tall
+ * as the font's ascent. That way if there are a bunch of
+ * circled things and one is tiny, like a dot, that circle
+ * won't be vastly smaller than the others. */
+ min_height = fontascent(font, size);
+ if (uncirc_height < min_height) {
+ adjust = min_height - uncirc_height;
+ uncirc_height = min_height;
+ }
+ else {
+ adjust = 0.0;
+ }
+
+ /* Allow 25% of the height above and below as space for the circle. */
+ circ_extra = 0.25 * uncirc_height;
+ circ_height = 2.0 * circ_extra + uncirc_height;
+
+ /* If width is up to 110% of the height, use the circled
+ * height as the circled width as well. */
+ if (uncirc_width <= 1.1 * uncirc_height) {
+ circ_width = circ_height;
+ }
+ else {
+ /* make a little taller to compensate for the width */
+ circ_extra += circ_height * .03 * (uncirc_width / uncirc_height);
+ circ_height = 2.0 * circ_extra + uncirc_height;
+
+ /* Use 50% of the circled height as the amount to add
+ * to the width, 25% on each end. */
+ circ_width = uncirc_width + 0.5 * circ_height;
+ }
+ if (height_p != 0) {
+ *height_p = circ_height;
+ }
+ if (width_p != 0) {
+ *width_p = circ_width;
+ }
+ if (x_offset_p != 0) {
+ *x_offset_p = (circ_width - uncirc_width) / 2.0;
+ }
+ if (ascent_adjust != 0) {
+ *ascent_adjust = adjust;
+ }
+
+ return(circ_extra);
+}
+\f
+
+/* Return proper version of rehearsal mark string, based on staff number.
+ * It may be circled, boxed, or plain. If circled or boxed, a new string
+ * is returned. If plain, the string is returned as is.
+ */
+
+char *
+get_reh_string(string, staffnum)
+
+char *string; /* the plain rehearsal mark string */
+int staffnum; /* which staff it is for */
+
+{
+ char reh_buffer[100]; /* if not okay as it is, copy is put here */
+ int style;
+
+ style = svpath(staffnum, REHSTYLE)->rehstyle;
+
+ if (style == RS_PLAIN) {
+ return(string);
+ }
+
+ if (strlen(string) + 3 > sizeof(reh_buffer)) {
+ /* Usually reh marks are very short,
+ * so if this one is really long, too bad.
+ */
+ ufatal("rehearsal mark is too long");
+ }
+
+ (void) sprintf(reh_buffer, "%c%s%c",
+ style == RS_CIRCLED ? STR_CIR : STR_BOX,
+ string + 2,
+ style == RS_CIRCLED ? STR_CIR_END : STR_BOX_END);
+ return(copy_string(reh_buffer, string[0], string[1]));
+}
+\f
+
+/* Map STR_MUS_CHAR* to FONT_MUSIC* */
+
+int
+str2mfont(str)
+
+int str; /* STR_MUS_CHAR* */
+
+{
+ switch (str) {
+ case STR_MUS_CHAR:
+ return(FONT_MUSIC);
+ case STR_MUS_CHAR2:
+ return(FONT_MUSIC2);
+ default:
+ pfatal("impossible str 0x%x in str2mfont", str);
+ /*NOTREACHED*/
+ return(FONT_MUSIC);
+ }
+}
+
+/* Map FONT_MUSIC* to STR_MUS_CHAR* */
+
+int
+mfont2str(mfont)
+
+int mfont; /* FONT_MUSIC* */
+
+{
+ switch (mfont) {
+ case FONT_MUSIC:
+ return(STR_MUS_CHAR);
+ case FONT_MUSIC2:
+ return(STR_MUS_CHAR2);
+ default:
+ pfatal("impossible mfont %d in mfont2str", mfont);
+ /*NOTREACHED*/
+ return(STR_MUS_CHAR);
+ }
+}
~mdw / mup / blobdiff