Import upstream version 5.3.

[mup] / mup / mup / defines.h

/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 * 2006 by Arkkra Enterprises */
/* All rights reserved */
/*
 *      defines.h
 *
 *      This file defines the constants needed for the music publication
 *      program.
 */

#include <math.h>
#ifndef _DEFINES
#define _DEFINES
#include "muschar.h"

/*
 * Define the environment =============================================
 */

/* for all forms of DOS we've tried, make sure __DOS__ is defined */
#if defined(__TURBOC__) || defined(__WATCOMC__) || defined(__MINGW32__)
#ifndef __DOS__
#define __DOS__
#endif
#endif

/* if you are short on memory or know you'll never use the extended character
 * set (with accented characters, etc) you can undefine EXTCHAR
 */
#ifndef __TURBOC__
#define EXTCHAR
#endif
#include "extchar.h"

/* the following is needed for the DOS port of the GNU C compiler */
#ifdef __DJGPP__
#define __DOS__
#undef unix
#endif

/*
 * Based on system type, #define or don't #define various symbols, as follows:
 *
 * UNIX_LIKE_FILES      If defined, files can be simultaneously read from and
 *                      written to and invisibly unlinked.
 * UNIX_LIKE_PATH_RULES If defined, use these rules for MUPPATH.
 * DOS_LIKE_PATH_RULES  If defined, use these rules for MUPPATH.
 * CORE_MESSAGE         If defined, then a creating core error message will be
 *                      printed in debug mode.
 * NEED_GETOPT          If defined, the getopt suite is not available,
 *                      therefore use the limited one in main.c.
 * MAGIC_FILE_HOME      If defined, check for magic file in $HOME.
 * MAGIC_FILE_NAME      Name of magic file.
 * OPTION_MARKER        The char which preceeds command line options.
 */
#ifdef unix
#define UNIX_LIKE_FILES
#define UNIX_LIKE_PATH_RULES
#define CORE_MESSAGE
#define MAGIC_FILE_HOME
#define MAGIC_FILE_NAME ".mup"
#define OPTION_MARKER   '-'
#endif

#ifdef VMS
#define MAGIC_FILE_HOME
#define MAGIC_FILE_NAME ".mup"
#define OPTION_MARKER   '-'
#endif

#ifdef AMIGA
#undef  UNIX_LIKE_FILES
#define NEED_GETOPT
#define MAGIC_FILE_HOME
#define MAGIC_FILE_NAME ".mup"
#define OPTION_MARKER   '-'
#endif

#ifdef __DOS__
#define DOS_LIKE_PATH_RULES
#define NEED_GETOPT
#define MAGIC_FILE_NAME "mup.ok"
#define OPTION_MARKER   '/'
#endif

#ifdef Mac_BBEdit
#undef  UNIX_LIKE_FILES
#define NEED_GETOPT
/* skip length byte of Pascal string literal */
#define MAGIC_FILE_NAME (char *)(MupRegFileName + 1);
#define OPTION_MARKER   '-'
#endif

#ifdef __EMX__
#undef  UNIX_LIKE_FILES
#define DOS_LIKE_PATH_RULES
#define MAGIC_FILE_HOME
#define MAGIC_FILE_NAME ".mup"
#define OPTION_MARKER   '-'
#endif

#ifndef OPTION_MARKER
/* use - as default if nothing has been defined for it */
#define OPTION_MARKER '-'
#endif

/*
 * Define ranges for variables =============================================
 */

/*
 * Define maximum value for exit code from Mup. Must be less than 128
 * to be able to distinguish from WAIT_ABANDONED value on Windows.
 */
#define MAX_ERRORS      (127)

/* text point sizes */
#define MINSIZE (1)
#define MAXSIZE (100)

/* key signatures */
#define MINSHARPS       (-7)
#define MAXSHARPS       (7)
#define DEFSHARPS       (0)

/* octave */
#define MINOCTAVE       (0)
#define MAXOCTAVE       (9)
#define DEFOCTAVE       (4)

/* staves */
#define MINSTAFFS       (1)
#define MAXSTAFFS       (40)
#define DEFSTAFFS       (1)

/* voices */
#define MINVOICES       (1)
#define NORMVOICES      (2)
#define MAXVOICES       (3)

/* number of lines in a tablature staff */
#define MINTABLINES     (1)
#define DEFTABLINES     (6)     /* see Guitar[] in globals.c */
#define MAXTABLINES     (9)

/* number of ticks on a string designation for tablature */
#define MINTICKS        (0)
#define MAXTICKS        (MAXTABLINES - 1)

#define TABDEFOCT       (4)

/* tablature fret numbers, including pseudo fret numbers */
#define MINFRET         (0)
#define MAXFRET         (99)
#define DEFFRET         (0)
#define NOFRET          (MAXFRET + 1)
#define IN_UPWARD       (MAXFRET + 2)   /* slur from nowhere, going up */
#define IN_DOWNWARD     (MAXFRET + 3)   /* slur from nowhere, going down */
#define OUT_UPWARD      (MAXFRET + 4)   /* slur to nowhere, going up */
#define OUT_DOWNWARD    (MAXFRET + 5)   /* slur to nowhere, going down */
#define IS_NOWHERE(fret) ((fret) >= IN_UPWARD && (fret) <= OUT_DOWNWARD)

/* range of frets that can be printed by a chord grid */
#define MINGRIDFRET     (2)
#define MAXGRIDFRET     (MAXFRET)
#define DEFGRIDFRET     (4)
#define NOGRIDFRET      (-1)    /* must be negative so user can't enter it */

/* USE_DFLT_OCTAVE has to be number that is not a valid octave, nor a */
/* valid fret number.  But it has to be positive and small enough to be */
/* able to add MAX_OCTAVE to it */
#define USE_DFLT_OCTAVE (MAXFRET + 6)

/* min and max numbers for bend integers, numerators, and denominators */
#define BENDINTBITS     (4)
#define MINBENDINT      (0)
#define MAXBENDINT      ((1 << BENDINTBITS) - 1)
#define BENDNUMBITS     (6)
#define MINBENDNUM      (0)
#define MAXBENDNUM      ((1 << BENDNUMBITS) - 1)
#define BENDDENBITS     (6)
#define MINBENDDEN      (1)
#define MAXBENDDEN      ((1 << BENDDENBITS) - 1)

/* time unit */
/* -1 means quadruple whole and 0 means double whole.  Actually, less than -1 */
/* is allowed, and it's minus the number of measures in a multirest */
#define MINBASICTIME    (-1)
#define MAXBASICTIME    (256)

/* the biggest number that is allowed on a multirest */
#define MAXMULTINUM     (1000)

/* limits for scaling the output */
#define MINSCALE        (0.1)
#define MAXSCALE        (10.0)
#define DEFSCALE        (1.0)

/* limits for scaling a staff relative to the output as a whole */
#define MINSTFSCALE     (0.1)
#define MAXSTFSCALE     (10.0)
#define DEFSTFSCALE     (1.0)

#define MINGRIDSCALE    (0.1)
#define MAXGRIDSCALE    (10.0)
#define DEFGRIDSCALE    (1.0)

/* limits on min distance required between a chord and its staff (stepsizes) */
#define MINCHORDDIST    (0)
#define MAXCHORDDIST    (50)
#define DEFCHORDDIST    (3)

/* limits on min dist required between other stuff and its staff (stepsizes) */
#define MINDIST         (0)
#define MAXDIST         (50)
#define DEFDIST         (2)

/* limits on min distance required between a cresc and its staff (stepsizes) */
#define MINDYNDIST      (0)
#define MAXDYNDIST      (50)
#define DEFDYNDIST      (0)

/* vertical space between staffs and scores, in units of stepsize */
#define MINMINSTSEP     (6)     /* min user-specified min between staffs */
#define DEFMINSTSEP     (10)    /* default min between staffs */
#define MINMINSCSEP     (6)     /* min user-specified min between scores */
#define DEFMINSCSEP     (12)    /* default min between scores */
#define MINMAXSCSEP     MINMINSCSEP /* min user-specified max between scores */
#define DEFMAXSCSEP     (20)    /* default max between scores */
#define MAXSEPVAL       ((int)(PGHEIGHT / STEPSIZE)) /* max for either one */
#define MINSTPAD        (-MAXSEPVAL) /* min user-spec. white between staffs */
#define MAXSTPAD        (MAXSEPVAL) /* max user white between staffs */
#define DEFSTPAD        (0)     /* default white between staffs */
#define MINMINSCPAD     (-MAXSEPVAL) /* min user-spec. white between scores */
#define DEFMINSCPAD     (2)     /* default white between scores */
#define MINMAXSCPAD     (-MAXSEPVAL) /* min user-spec. white between scores */
#define DEFMAXSCPAD     (2)     /* default white between scores */
#define MAXPADVAL       (MAXSEPVAL) /* max user white between scores */

/* distance from center line a rest should be forced to be */
#define MINRESTDIST     (-50)
#define MAXRESTDIST     (50)
#define NORESTDIST      (11111) /* this means it is not set */

/* number of mr needed to combine into a multirest (like -c option) */
#define MINRESTCOMBINE  (2)
#define MAXRESTCOMBINE  (1000)
#define NORESTCOMBINE   (-1)    /* must be negative so user can't enter it */

/* page number to be put on the first page (like -p option) */
#define MINFIRSTPAGE    (1)
#define MAXFIRSTPAGE    (5000)
#define NOFIRSTPAGE     (0)     /* this means it is not set */

/* number to multiply linear regression slope by to get beam's slope */
#define MINBEAMFACT     (0.0)
#define MAXBEAMFACT     (1.0)
#define DEFBEAMFACT     (1.0)

/* maximum beam angle allowed, in degrees */
#define MINBEAMMAX      (0.0)
#define MAXBEAMMAX      (45.0)
#define DEFBEAMMAX      (20.0)

/* angle of beam specified by the "slope" interchord attribute */
#define MINBEAMANGLE    (-MAXBEAMMAX)
#define MAXBEAMANGLE    (MAXBEAMMAX)
#define NOBEAMANGLE     (2 * MAXBEAMANGLE)      /* something out of range */

/* padding to be applied on the left of every group (and the right of the */
/* last group in the measure), in stepsizes */
#define MINPAD          (-5.0)
#define MAXPAD          (50.0)
#define DEFPAD          (0.0)

/* for setting and testing unknown stem length */
#define STEMLEN_UNKNOWN         (-1.0)
#define IS_STEMLEN_KNOWN(x)     ((x) >= 0.0)    /* avoid using "==" on floats */
#define IS_STEMLEN_UNKNOWN(x)   ((x) < 0.0)     /* avoid using "==" on floats */

/* other stem length definitions */
#define MINSTEMLEN      (0.0)
#define DEFSTEMLEN      (7.0)
#define MAXSTEMLEN      (100.0)
#define SM_STEMFACTOR   (5.0 / 7.0)     /* grace/cue factor */

/* number of stepsizes by which a beamed stem can be shortened */
#define MINSTEMSHORTEN  (0.0)
#define MAXSTEMSHORTEN  (2.0)
#define DEFSTEMSHORTEN  (1.0)

/* what fraction of each lyrics syllable goes left of the center of chord */
#define MINLYRICSALIGN  (0.0)
#define MAXLYRICSALIGN  (1.0)
#define DEFLYRICSALIGN  (0.25)

/* size of the paper */
#define MINPAGEHEIGHT   (2.0)
#define MAXPAGEHEIGHT   (24.0)
#define DEFPAGEHEIGHT   (11.0)
#define MINPAGEWIDTH    (2.0)
#define MAXPAGEWIDTH    (24.0)
#define DEFPAGEWIDTH    (8.5)

/* top and bottom margins */
#define MINVMARGIN      (0.0)
#define MAXVMARGIN      (3.0)
#define DEFVMARGIN      (0.5)

/* left and right margins */
#define MINHMARGIN      (0.0)
#define MAXHMARGIN      (3.0)
#define DEFHMARGIN      (0.5)

/* panels per page */
#define MINPANELSPERPAGE        (1)
#define MAXPANELSPERPAGE        (2)
#define DEFPANELSPERPAGE        (1)

/* how tightly to pack the stuff horizontally (default value) */
#define MINPACKFACT     (0.0)
#define DFLTPACKFACT    (1.0)
#define MAXPACKFACT     (10.0)

/* how much to expand long notes relative to short ones */
#define MINPACKEXP      (0.0)
#define DFLTPACKEXP     (0.8)
#define MAXPACKEXP      (1.0)

/* time signature */
#define MINNUMERATOR    (1)
#define MAXNUMERATOR    (99)

#define MINDENOMINATOR  (1)
#define MAXDENOMINATOR  (64)

#define MINDIVISION     (1)
#define DEFDIVISION     (192)
#define MAXDIVISION     (3 * 512)

/* define values for the "release" parameter, in milliseconds */
#define MINRELEASE      (0)
#define DEFRELEASE      (20)
#define MAXRELEASE      (500)

/* define values for the "sylposition" parameter, in points */
#define MINSYLPOSITION  (-100)
#define MAXSYLPOSITION  (100)
#define DEFSYLPOSITION  (-5)
#define NOSYLPOSITION   (11111) /* this means it is not set */


/*
 * Define sets of symbols which probably should have been done as enums,
 * but in ANSI C enums aren't much good anyhow.  =============================
 * Also define some macros for testing these enums.
 */

/*
 * To limit the number of terminal symbols so that yacc won't blow up,
 * several tokens map to the same terminal symbol, and we set a variable
 * (yylval) to say which particular one was actually seen.
 */
#define F_STAFFS        (1)
#define F_OCTAVE        (2)
#define F_LYRSIZE       (3)
#define F_VERTSPACE     (4)
#define F_SIZE          (5)

#define F_TOPMARGIN     (6)
#define F_BOTMARGIN     (7)
#define F_LEFTMARGIN    (8)
#define F_RIGHTMARGIN   (9)

#define F_TIMEUNIT      (10)
#define F_VSCHEME       (11)

#define F_BRACKET       (12)
#define F_BRACE         (13)
#define F_BARSTYLE      (14)

#define F_LABEL         (15)
#define F_LABEL2        (16)

#define F_FONT          (17)
#define F_LYRFONT       (18)

#define F_VISIBLE       (19)
#define F_VERSES        (20)

/*
 * Define all the types of context in the input.  Make each one a bit, so that
 * we can also define a couple groupings of them.
 */
#define C_HEADER        (0x1)   /* first page header */
#define C_FOOTER        (0x2)   /* first page footer */
#define C_HEAD2         (0x4)   /* later page header */
#define C_FOOT2         (0x8)   /* later page footer */
#define C_TOP           (0x10)  /* initial block at top */
#define C_BOT           (0x20)  /* initial block at bottom */
#define C_TOP2          (0x40)  /* later block at top */
#define C_BOT2          (0x80)  /* later block at bottom */
#define C_BLOCK         (0x100) /* other block */
#define C_SCORE         (0x200) /* the whole score */
#define C_STAFF         (0x400) /* a staff */
#define C_VOICE         (0x800) /* a voice */
#define C_MUSIC         (0x1000) /* notes, etc. */
#define C_GRIDS         (0x2000) /* chord grids */
#define C_HEADSHAPES    (0x4000) /* head shapes for notehead characters */

/* context classes--combining things that mostly have the same rules */
#define C_BLOCKHEAD     (C_HEADER | C_FOOTER | C_HEAD2 | C_FOOT2 | \
                        C_TOP | C_BOT | C_TOP2 | C_BOT2 | C_BLOCK)
#define C_SSV           (C_SCORE | C_STAFF | C_VOICE)

/* define whether things are measured in inches or centimeters */
#define INCHES          (0)
#define CM              (1)

/*
 * Define the voice schemes.  V_1 means just one voice is on the staff;
 * the program will decide the stem direction of each group.  V_2OPSTEM
 * means there are two voices with opposing stems:  the first voice always
 * points up, and the second one always points down.  V_2FREESTEM means there
 * are two voices.  If, at any time, one has a space, the other one's stems
 * can point either way (as with one voice).  Otherwise, the first voice
 * points up and the second one down.
 * V_3OPSTEM and V_3FREESTEM are just like the "2" ones, except that a third
 * voice is allowed to exist.  Its stem direction is determined elsewhere.
 */
#define V_1             (0)
#define V_2OPSTEM       (1)
#define V_2FREESTEM     (2)
#define V_3OPSTEM       (3)
#define V_3FREESTEM     (4)

/*
 * Define the modes of the voicecombine parameter.
 */
/* bottom note of high voice must be higher than top note of low voice */
#define VC_NOOVERLAP    (0)
/* bottom note of high voice must be no lower than top note of low voice */
#define VC_SHAREONE     (1)
/* no restrictions */
#define VC_OVERLAP      (2)

/*
 * Define the staff style vis-a-vis printing of clefs, accidentals (in key
 * signatures and otherwise), and tranposing.  WARNING:  SS_NOTHING must be
 * defined to be 0 so that calloc inits the field to this.
 */
#define SS_NOTHING      (0)     /* no transpose; print no clef, no accidentals*/
#define SS_NORMAL       (1)     /* normal printing */
#define SS_DRUM         (2)     /* like SS_NOTHING, but print a "drum clef" */

/*
 * Define the time signature types.  NUMERIC is the usual two-number
 * signature.  INVISNUM is the same, except that it will not be printed.
 * Common and cut time are noted here separately.  But for all other
 * purposes they are treated as 4/4 and 2/2 respectively.
 */
#define TS_NUMERIC      (0)
#define TS_INVISNUM     (1)
#define TS_COMMON       (2)
#define TS_CUT          (3)

/*
 * Special bytes used inside time signature representation.
 * These values need to be outside the range of time signature numerators
 * and denominators, but small enough to fit in a byte.
 * Probably safer to keep them under 128 as well, to avoid any possible
 * issues with negative chars.
 *
 * Here's how the encoding works:
 * cut and common get stored as TSR_CUT and TSR_COMMON respectively.
 * If a + is used between a denominator of one fraction
 * and numerator of another, it is encoded as TSR_ADD.
 * When a + is used inside a numerator, nothing is stored at all,
 * since it is clear all numbers up to the slash
 * must be components of the numerator.
 * White space rather than + after a denominator
 * means alternating time signatures, marked internally by TSR_ALTERNATING.
 * Numbers are stored as their binary values.
 * A TSR_END is placed at the end of everything to mark the end.
 * A null is used for that, so one could use things like strlen or strcpy
 * on a representation.
 */
#define TSR_CUT         (MAXNUMERATOR + 1)
#define TSR_COMMON      (MAXNUMERATOR + 2)
#define TSR_SLASH       (MAXNUMERATOR + 3)
#define TSR_ADD         (MAXNUMERATOR + 4)
#define TSR_ALTERNATING (MAXNUMERATOR + 5)
#define TSR_END         (0)

/*
 * This is the maximum length of an internal time signature representation.
 * Note that the internal form is more compact than the input form,
 * so even something so ridiculously complicated that it's doubtful any
 * human could keep it straight, like
 *   3+1+4/16 + cut + 7+11+41/2  9+2/64 + 5+7+31+29/1 + com
 * would only take 28 bytes, so 40 should be plenty!
 * The maximum number of numerator components 40 bytes could accomodate
 * would be 37, so maximum theoretical effective time signature
 * would be thirty-seven 99's or 3663 counts.
 */
#define MAXTSLEN        40

/*
 * Define when time signatures should be printed.  "Once" means when it
 * changes.  "Always" makes sense only when there is an alternating time sig,
 * and it means print it at each measure.
 */
#define PTS_NEVER       (0)     /* user input "n" */
#define PTS_ONCE        (1)     /* user input nothing */
#define PTS_ALWAYS      (2)     /* user input "y" */

/*
 * Define the clefs that are allowed.  The values are important, so that
 * the program can conveniently figure note positions without having a
 * separate case for each value.
 */
#define TREBLE_8A       (-7)
#define FRENCHVIOLIN    (-2)
#define TREBLE          (0)
#define SOPRANO         (2)
#define MEZZOSOPRANO    (4)
#define ALTO            (6)
#define TREBLE_8        (7)
#define TENOR           (8)
#define BARITONE        (10)
#define BASS            (12)
#define TABCLEF         (-1)    /* tablature "clef" */
#define NOCLEF          (-99)   /* no clef is present */

/*
 * Define what a GRPSYL structure can represent.
 */
#define GS_GROUP        (0)
#define GS_SYLLABLE     (1)

/*
 * Define the different contents a group can have.
 */
#define GC_NOTES        (0)
#define GC_REST         (1)
#define GC_SPACE        (2)

/*
 * Define the time values a group can have.  Only note groups can be other than
 * normal (grace notes).  There are no grace rests or spaces.
 */
#define GV_NORMAL       (0)
#define GV_ZERO         (1)

/*
 * Define the unknown value for headshapes.  The other values aren't defined
 * here because they are established as headshapes are loaded at run time.
 * There is a built-in set of these that are loaded, and then the user can use
 * the "headshapes" context to load more.  Each headshape number corresponds to
 * a headshape name, such as "norm", "xnote", "rect", etc., and stands for the
 * set of music characters used to print note heads of the various basictimes.
 */
#define HS_UNKNOWN      (0)

/*
 * Define the size of a group.  Spaces are always normal, but notes and rests
 * can have different sizes.  For note groups, this can vary on a per-note
 * basis.
 */
#define GS_NORMAL       (0)
#define GS_SMALL        (1)

/*
 * Define position that you can be in relative to a list of objects.
 */
#define NOITEM          (0)     /* not within a list */
#define STARTITEM       (1)     /* first item in a list */
#define INITEM          (2)     /* interior item in a list */
#define ENDITEM         (3)     /* last item in a list */
#define LONEITEM        (4)     /* only item in a list */


/*
 * Define the directions for various items.
 */
#define UNKNOWN (0)
#define UP      (1)
#define DOWN    (2)


/*
 * Define values for controlling printing of tuplet numbers and brackets.
 * For PT_DEFAULT, the bracket will be printed unless all the notes of the
 * tuplet (and no other notes) form a beamed set.
 */
#define PT_NEITHER      (0)     /* never print number or bracket */
#define PT_DEFAULT      (1)     /* always print number; maybe print bracket */
#define PT_BOTH         (2)     /* always print number and bracket */
#define PT_NUMBER       (3)     /* always print just the number */


/*
 * Coordinate types that can have location variables associated with them.
 */
#define CT_BUILTIN      (1)
#define CT_GRPSYL       (2)
#define CT_BAR          (4)
#define CT_NOTE         (8)
#define CT_INVISIBLE    (128)


/*
 * Define the types of STUFF structure.  "Stuff" is things that are to be
 * printed other than the actual music and lyrics.
 */
#define ST_ROM          (0)
#define ST_BOLD         (1)
#define ST_ITAL         (2)
#define ST_BOLDITAL     (3)
#define ST_CRESC        (4)
#define ST_DECRESC      (5)
#define ST_MUSSYM       (6)
#define ST_PEDAL        (7)
#define ST_TIESLUR      (8)
#define ST_TABSLUR      (9)
#define ST_BEND         (10)
#define ST_PHRASE       (11)
#define ST_OCTAVE       (12)
#define ST_MIDI         (13)

#define IS_TEXT(stype)  ((stype) == ST_ROM || (stype) == ST_ITAL ||     \
                        (stype) == ST_BOLD || (stype) == ST_BOLDITAL)

/*
 * Define the places where the stuff can be printed, relative to staff(s).
 */
#define PL_ABOVE        (0)
#define PL_BELOW        (1)
#define PL_BETWEEN      (2)
#define PL_UNKNOWN      (3)
#define NUM_PLACE       (3)     /* number of "good" places (exclude unknown) */

/*
 * Define the ways a user can specify the horizonal offset of a group from the
 * chord's X coordinate.
 */
#define HO_NONE         (0)     /* not specified */
#define HO_LEFT         (1)     /* "-" (next to other group(s), on the left) */
#define HO_RIGHT        (2)     /* "+" (next to other group(s), on the right) */
#define HO_VALUE        (3)     /* "+/-N" (offset given by GRPSYL.ho_value) */

/*
 * Define text modifiers:  different flavors of rom, bold, ital, and
 * boldital.  TM_DYN also applies automatically to the hairpin stuffs, < and >.
 */
#define TM_NONE         (0)
#define TM_CHORD        (1)
#define TM_ANALYSIS     (2)
#define TM_FIGBASS      (3)
#define TM_DYN          (4)

#define IS_CHORDLIKE(x) ((x) == TM_CHORD || (x) == TM_ANALYSIS ||       \
                        (x) == TM_FIGBASS)

/*
 * Define values for dist_usage in STUFF.
 */
#define SD_NONE         (0)     /* user did not specify */
#define SD_MIN          (1)     /* user specified minimum distance */
#define SD_FORCE        (2)     /* user is forcing this distance */

/*
 * Define all the types of marks that the user can request to be stacked in
 * different orders.  This list is in increasing order of the default priority
 * of stacking, except that by default MK_DYN, MK_OTHERTEXT, and MK_CHORD are
 * of equal priority.  If this list changes, make sure that Defmarkorder[]
 * is updated too.  For each place (above, below, between), the user can
 * specify a different ordering of priority to be used.  There is a restriction
 * that the last ones (MK_LYRICS, MK_ENDING, MK_REHEARSAL, MK_PEDAL) must
 * have a different priority from each other and any of the other ones.  Also,
 * MK_PEDAL is allowed only below; MK_ENDING and MK_REHEARSAL are allowed only
 * above; and those three and MK_OCTAVE are not allowed between.
 */
#define MK_MUSSYM       (0)     /* ST_MUSSYM */
#define MK_OCTAVE       (1)     /* ST_OCTAVE */
#define MK_DYN          (2)     /* ST_CRESC or ST_DECRESC; or ST_ROM, */
                                /* ST_ITAL, ST_BOLD, ST_BOLDITAL with "dyn" */
                                /* (TM_DYN is set for these and only these) */
#define MK_OTHERTEXT    (3)     /* ST_ROM, ST_ITAL, ST_BOLD, ST_BOLDITAL */
                                /* without chord/analysis/figbass or dyn */
#define MK_CHORD        (4)     /* ST_ROM, ST_ITAL, ST_BOLD, ST_BOLDITAL */
                                /* with chord, analysis, or figbass */
                                /* (TM_CHORD is set for these and only these) */
#define MK_LYRICS       (5)     /* lyrics */
#define MK_ENDING       (6)     /* ending mark */
#define MK_REHEARSAL    (7)     /* rehearsal mark */
#define MK_PEDAL        (8)     /* ST_PEDAL */
#define NUM_MARK        (9)     /* this must follow the last MK */

/*
 * While parsing, we need to temporarily store some things as pseudo-pitches.
 * When the user does not specify any pitch for the first group of a measure,
 * we temporarily use PP_NO_PITCH, since not specifying a pitch is legal iff it
 * is for one or more 1-line staffs, but it's not easy to check on that until
 * later.  We also need to save rest, space, and rpt as pseudo notes until we
 * later map them to groups.
 */
#define PP_NO_PITCH     'h'
#define PP_REST         'r'
#define PP_SPACE        's'
#define PP_RPT          'p'

/*
 * Define the other staff that a given staff's groups are beamed or stemmed to.
 */
#define CS_SAME         (0)
#define CS_ABOVE        (1)
#define CS_BELOW        (2)

/*
 * Define symbols for indexing coordinate arrays.  The first 12 are X, Y,
 * north, south, east, and west, both relative and absolute.  Not all things
 * that have coordinates bother to set all 12 of these.  There should be
 * comments in structs.h saying which things get set for what.
 *
 * In GRPSYL, during the time that positions of phrase marks are being
 * figured out, AN and AS are used in a strange way.  But later, they get
 * set to their intended values.
 *
 * The 13th is a special number used by nongrace notes and GRPSYLs, and BARs
 * only.  For notes and GRPSYLs, it has the following meaning.  It indicates
 * how many inches of horizontal space would be allocated to this object
 * if it were a whole note instead of whatever it actually is, but were
 * allocated space proportionally.  That is, fulltime times this number
 * is the amount of space between the X coordinates of this GRPSYL and
 * the next one in the measure (or the bar line if this is the last GRPSYL
 * in the measure).  Notice that even for notes, it's the X coordinate of
 * the note's GRPSYL that count, even if the note head is on the "wrong"
 * side of the stem.  For BARs, this 13th number has a similiar use.  If
 * you pretend that a bar line is count 0 of the following measure, and
 * the first GRPSYL of the measure is at count 1 (whichever type of note
 * constitutes a "count"), this number is how many inches would be allocated
 * to a whole note instead of the one count of space that is there.
 */
#define RX      (0)
#define RY      (1)
#define RN      (2)
#define RS      (3)
#define RE      (4)
#define RW      (5)
#define AX      (6)
#define AY      (7)
#define AN      (8)
#define AS      (9)
#define AE      (10)
#define AW      (11)
#define INCHPERWHOLE    (12)
#define NUMCTYPE        (13)


/*
 * AN and AS of group coordinates are used temporarily to store the distance
 * from the group to any phrase marks, to be used to make sure nesting phrases
 * don't impinge on that space. But if a group has a phrase ending on it and
 * another beginning on it, those won't collide.  So use bitmap to keep track
 * of whether the AN and AS values apply to east side, west side, or both.
 * (phraseside in GRPSYL is a bit map.)
 */
#define EAST_SIDE       (1 << 0)
#define WEST_SIDE       (1 << 1)


/*
 * Define the types of bar line.
 */
#define INVISBAR        (0)
#define SINGLEBAR       (1)
#define DOUBLEBAR       (2)
#define REPEATSTART     (3)
#define REPEATEND       (4)
#define REPEATBOTH      (5)
#define ENDBAR          (6)
#define RESTART         (7)

/*
 * Define the types of font, leaving 0 unused to avoid ending up having
 * null characters appear in strings where this number is stored,
 * and to have something convenient to use to flag an unknown font.
 * WARNING:  the getfontinfo.c program depends on all the font names
 * beginning with "FONT_", and on MAXFONTS being at the end of the list.
 */
#define FONT_UNKNOWN    (0)
#define FAMILY_DFLT     (-1)

#define BASE_TIMES      (0)
#define FONT_TR         (1)
#define FONT_TI         (2)
#define FONT_TB         (3)
#define FONT_TX         (4)

#define BASE_AVANTGARDE (FONT_TX)
#define FONT_AR         (BASE_AVANTGARDE + FONT_TR)
#define FONT_AI         (BASE_AVANTGARDE + FONT_TI)
#define FONT_AB         (BASE_AVANTGARDE + FONT_TB)
#define FONT_AX         (BASE_AVANTGARDE + FONT_TX)

#define BASE_COURIER    (FONT_AX)
#define FONT_CR         (BASE_COURIER + FONT_TR)
#define FONT_CI         (BASE_COURIER + FONT_TI)
#define FONT_CB         (BASE_COURIER + FONT_TB)
#define FONT_CX         (BASE_COURIER + FONT_TX)

#define BASE_HELVETICA  (FONT_CX)
#define FONT_HR         (BASE_HELVETICA + FONT_TR)
#define FONT_HI         (BASE_HELVETICA + FONT_TI)
#define FONT_HB         (BASE_HELVETICA + FONT_TB)
#define FONT_HX         (BASE_HELVETICA + FONT_TX)

#define BASE_BOOKMAN    (FONT_HX)
#define FONT_BR         (BASE_BOOKMAN + FONT_TR)
#define FONT_BI         (BASE_BOOKMAN + FONT_TI)
#define FONT_BB         (BASE_BOOKMAN + FONT_TB)
#define FONT_BX         (BASE_BOOKMAN + FONT_TX)

#define BASE_NEWCENTURY (FONT_BX)
#define FONT_NR         (BASE_NEWCENTURY + FONT_TR)
#define FONT_NI         (BASE_NEWCENTURY + FONT_TI)
#define FONT_NB         (BASE_NEWCENTURY + FONT_TB)
#define FONT_NX         (BASE_NEWCENTURY + FONT_TX)

#define BASE_PALATINO   (FONT_NX)
#define FONT_PR         (BASE_PALATINO + FONT_TR)
#define FONT_PI         (BASE_PALATINO + FONT_TI)
#define FONT_PB         (BASE_PALATINO + FONT_TB)
#define FONT_PX         (BASE_PALATINO + FONT_TX)

#ifdef EXTCHAR
/* extra fonts that contain the extended character set start here.
 * They go in the same order as their corresponding standard ASCII fonts */
#define EXT_FONT_OFFSET (FONT_PX - BASE_TIMES)

#define FONT_XTR        (FONT_TR + EXT_FONT_OFFSET)
#define FONT_XTI        (FONT_TI + EXT_FONT_OFFSET)
#define FONT_XTB        (FONT_TB + EXT_FONT_OFFSET)
#define FONT_XTX        (FONT_TX + EXT_FONT_OFFSET)

#define FONT_XAR        (FONT_AR + EXT_FONT_OFFSET)
#define FONT_XAI        (FONT_AI + EXT_FONT_OFFSET)
#define FONT_XAB        (FONT_AB + EXT_FONT_OFFSET)
#define FONT_XAX        (FONT_AX + EXT_FONT_OFFSET)

#define FONT_XCR        (FONT_CR + EXT_FONT_OFFSET)
#define FONT_XCI        (FONT_CI + EXT_FONT_OFFSET)
#define FONT_XCB        (FONT_CB + EXT_FONT_OFFSET)
#define FONT_XCX        (FONT_CX + EXT_FONT_OFFSET)

#define FONT_XHR        (FONT_HR + EXT_FONT_OFFSET)
#define FONT_XHI        (FONT_HI + EXT_FONT_OFFSET)
#define FONT_XHB        (FONT_HB + EXT_FONT_OFFSET)
#define FONT_XHX        (FONT_HX + EXT_FONT_OFFSET)

#define FONT_XBR        (FONT_BR + EXT_FONT_OFFSET)
#define FONT_XBI        (FONT_BI + EXT_FONT_OFFSET)
#define FONT_XBB        (FONT_BB + EXT_FONT_OFFSET)
#define FONT_XBX        (FONT_BX + EXT_FONT_OFFSET)

#define FONT_XNR        (FONT_NR + EXT_FONT_OFFSET)
#define FONT_XNI        (FONT_NI + EXT_FONT_OFFSET)
#define FONT_XNB        (FONT_NB + EXT_FONT_OFFSET)
#define FONT_XNX        (FONT_NX + EXT_FONT_OFFSET)

#define FONT_XPR        (FONT_PR + EXT_FONT_OFFSET)
#define FONT_XPI        (FONT_PI + EXT_FONT_OFFSET)
#define FONT_XPB        (FONT_PB + EXT_FONT_OFFSET)
#define FONT_XPX        (FONT_PX + EXT_FONT_OFFSET)

#define BASE_MISC       (FONT_XPX)
#else
#define BASE_MISC       (FONT_PX)
#endif
#define FONT_ZD         (BASE_MISC + 1)
#define FONT_ZI         (BASE_MISC + 2)
#define FONT_MUSIC      (BASE_MISC + 3)
#define FONT_MUSIC2     (BASE_MISC + 4)
#define MAXFONTS        (BASE_MISC + 5)

/* number of music fonts */
#define NUM_MFONTS      (2)

/* first printable character in a font */
#define FIRST_CHAR      (32)

/*
 * The following value plus FIRST_CHAR needs to be at least as large as
 * one more than the largest value in either muschar.h or extchar.h
 */
#define CHARS_IN_FONT   (96)

/*
 * Find array offset into height, width, and ascent tables.  This is character
 * code -FIRST_CHAR, to skip ASCII control characters.
 */
#define CHAR_INDEX(c)   ((c) - FIRST_CHAR)

/*
 * Test if a font is a "music" font.
 */
#define IS_MUSIC_FONT(f)        ((f) == FONT_MUSIC || (f) == FONT_MUSIC2)

/*
 * Special commands to use inside internal format of strings.
 * All use high-bit==1 to indicate a command.
 * Note that the low order bits of STR_MUS_CHAR* specify which music font it is.
 */
#define STR_MUS_CHAR            0x80    /* followed by 1-byte size and 1-byte \
                                         * music character code */
#define STR_MUS_CHAR2           0x81    /* same rules as above */
#define STR_FONT                0xe0    /* followed by 1-byte font number */
#define STR_SIZE                0xe1    /* followed by 1-byte size */
#define STR_PAGENUM             0xe2    /* followed by '%' */
#define STR_NUMPAGES            0xe3    /* followed by '#' */
#define STR_PRE                 0xe4    /* pre-syl <--->, ignored in spacing */
#define STR_U_PRE               0xe5    /* pre-syl <...>, used in spacing */
#define STR_PRE_END             0xe6    /* end of pre-syllable <...> */
#define STR_PST                 0xe7    /* post-syl <...>, ignored in spacing */
#define STR_U_PST               0xe8    /* post-syl <...>, used in spacing */
#define STR_PST_END             0xe9    /* end of post-syllable <...> */
/*
 * Backspace is a bit strange.  The amount to back up varies because of
 * proportionally spaced fonts.  So we save the distance in terms of the width
 * in 250ths of an inch in the default size.  The actual distance to back up is
 * then that number times the ratio of the current actual size to the default
 * size divided by 250.  250 was chosen because that means a range of 1-127
 * (to make sure it is non-zero and with high-bit of zero)
 * will give a range of .004 to 0.508 inches, which should cover all
 * characters we have today (the widest of which is currently just over 1/4").
 * This is done in floating point, so no reason to use a power of 2 like 256.
 */
#define STR_BACKSPACE           0xea    /* followed by how much to back up */

#define BACKSP_FACTOR           (250.0)

/* string commands for boxed text */
#define STR_BOX                 0xeb
#define STR_BOX_END             0xec
#define IS_BOXED(string)   (((string[2] & 0xff) == (STR_BOX & 0xff)) ? YES : NO)

#define STR_VERTICAL            0xed    /* vert move followed by 1-byte dist */
#define STR_L_ALIGN             0xee    /* align at left edge of next char */
#define STR_C_ALIGN             0xef    /* align at center of next char */
#define STR_PILE                0xf0    /* toggle for piling, \: */
#define STR_SLASH               0xf1    /* slash used by figbass, \/ */

/* string commands for circled text */
#define STR_CIR                 0xf2
#define STR_CIR_END             0xf3
#define IS_CIRCLED(string) (((string[2] & 0xff) == (STR_CIR & 0xff)) ? YES : NO)

/*
 * Define macros relating to vertical movement within a string.  It is stored
 * in points, offset by a bias so that the number will always be positive when
 * stored in the byte after the STR_VERTICAL in a string.
 */
#define MINVERTICAL     (-50)
#define MAXVERTICAL     (50)
#define VERT_BIAS       (1 - MINVERTICAL)
#define ENCODE_VERT(x)  (x + VERT_BIAS)
#define DECODE_VERT(x)  (x - VERT_BIAS)

/*
 * Macro to determine if a character in an internal-format string is a
 * command character.
 */
#define IS_STR_COMMAND(c)       ((c) & 0x80)


#define DFLT_SIZE       (12)
#define SMALLSIZE       ((int)(DFLT_SIZE * SM_FACTOR))

/*
 * Define the default font size of a measure number.
 */
#define MNUM_SIZE       (11)

/*
 * Define types of lines and curves.
 */
#define L_NORMAL        (0)
#define L_MEDIUM        (1)
#define L_WIDE          (2)
#define L_WAVY          (3)
#define L_DOTTED        (4)
#define L_DASHED        (5)

/*
 * Define the kinds of justification.
 */
#define J_LEFT          (1)
#define J_RIGHT         (2)
#define J_CENTER        (3)
#define J_NONE          (4)
#define J_RAGPARA       (5)     /* ragged-right paragraph */
#define J_JUSTPARA      (6)     /* justified paragraph */

/*
 * Define the ending styles (which staffs 1st, 2nd, etc. endings are to
 * be drawn on).
 */
#define ENDING_TOP      (0)     /* only above top visible staff */
#define ENDING_BARRED   (1)     /* above each group of staffs barred together*/
#define ENDING_GROUPED  (2)     /* above each group of staffs grouped */
                                /*  together by braces or brackets */

/*
 * Define types of rehearsal letters/numbers.
 */
#define REH_NONE        (0)     /* none at all */
#define REH_STRING      (1)     /* user-supplied string */
#define REH_NUM         (2)     /* consecutive numbers 1, 2, 3, . . . */
#define REH_LET         (3)     /* consecutive letters A, B, C, . . . */
#define REH_MNUM        (4)     /* use current measure number */

/*
 * Define the style of (ways of drawing) rehearsal letters/numbers.
 */
#define RS_PLAIN        (0)     /* just the letter/number */
#define RS_BOXED        (1)     /* enclosed in a box */
#define RS_CIRCLED      (2)     /* enclosed in a circle */

/*
 * Define the ways to print pedal markings.
 */
#define P_LINE          (0)     /* draw a line under where the pedal is down */
#define P_PEDSTAR       (1)     /* print "Ped." and the start and "*" at end */
#define P_ALTPEDSTAR    (2)     /* like P_PEDSTAR but only "Ped." when bounce*/

/*
 * Define the side of a stem that a partial beam can be on.  There is code in
 * prntdata.c that depends on these values, -1 and 1.
 */
#define PB_LEFT         (-1)
#define PB_RIGHT        (1)

/*
 * Define types of intervals.  There is code that depends on these being in
 * this order, starting from 0, counting up (like in trnspose.c).
 */
#define DIMINISHED      (0)
#define MINOR           (1)
#define PERFECT         (2)
#define MAJOR           (3)
#define AUGMENTED       (4)

/*
 * Define the input style.
 */
#define IS_VOICE_INPUT  (0)     /* voice-at-a-time (must be zero) */
#define IS_CHORD_INPUT  (1)     /* chord-at-a-time */

/*
 * Define the valid page sizes. The values must match the indexes of
 * pagesztbl in gram.y.
 */
#define PS_LETTER       (0)
#define PS_LEGAL        (1)
#define PS_FLSA         (2)
#define PS_HALFLETTER   (3)
#define PS_A4           (4)
#define PS_A5           (5)
#define PS_A6           (6)

/* Define page orientations */
#define O_PORTRAIT      (0)
#define O_LANDSCAPE     (1)

/*
 * Define various constants =============================================
 */

/* the number of PostScript points in one inch */
#define PPI             (72.0)

/* the size of a point in inches */
#define POINT           (1.0 / PPI)

/* the distance between a note and the next higher note */
#define STEPSIZE        (3.0 * POINT)

/* size of white space for surrounding things that should be padded thus */
#define STDPAD          (STEPSIZE / 3.0)

/* (distance between tab staff lines) / (distance between normal staff lines)*/
#define TABRATIO        (1.735)

/* scaling factor giving size of "sm" (small) music chars relative to normal */
#define SM_FACTOR       (0.65)

/* scaling factor giving size of a grace fret number relative to normal */
#define SMFRETSIZE      ((int)(0.80 * DFLT_SIZE))

/* font character size information is stored in FONTFACTORs of an inch */
#define FONTFACTOR      (1000.0)

/* widths of various types of lines, in points */
#define W_NORMAL        (0.7)
#define W_MEDIUM        (1.5)
#define W_WIDE          (3.0)

/* vertical distance between two flags or two beams */
#define FLAGSEP         (1.6 * STEPSIZE)        /* for normal notes */
#define SMFLAGSEP       (FLAGSEP * SM_FACTOR)   /* for cue or grace notes */

/* minimum width to be given to a multirest */
#define MINMULTIWIDTH   (0.7)

/* temporary width for a measure rest, serves as a marker */
#define TEMPMRPTWIDTH   (0.02)

/* half the width of a restart bar */
#define HALF_RESTART_WIDTH      (12 * POINT)

/* padding provided to force more room between groups for various reasons */
#define TIESLURPAD      (0.12)  /* ties and slurs */
#define SLASHPAD        (0.06)  /* slashes through stems */
#define ALTPAD          (0.12)  /* alternation beams between groups */
#define ROLLPADDING     (12 * STDPAD)   /* a roll to the left of a group */

/* padding to be put after a clef */
#define CLEFPAD         (2.0 * STDPAD)

/* how high certain things are */
#define TUPHEIGHT       (10.0/3.0 * STEPSIZE)   /* tuplet bracket */
#define OCTHEIGHT       (10.0/3.0 * STEPSIZE)   /* octave bracket */
#define ENDINGHEIGHT    (13.0/3.0 * STEPSIZE)   /* ending bracket */
#define MULTIHEIGHT     (12.0/3.0 * STEPSIZE)   /* multirest number */
#define MINWITHHEIGHT   (2.2 * STEPSIZE)        /* minimum "with" list item */

/* horizontal extent of a slash, in stepsizes */
#define SLASHHORZ       (5.0 / 3.0)

/*
 * The maximum number of notes there could ever be in a "hand" (the notes of a
 * chord that occur on a given staff) is the number of unique notes that can
 * exist, C0 through B9.
 */
#define MAXHAND         ((MAXOCTAVE - MINOCTAVE + 1) * 7)

/* the length in the X direction of a tabslur to or from nowhere */
#define SLIDEXLEN       (3.0 * STEPSIZE)

/* define the default distance, in stepsizes, between the lines of a grid */
#define WHEREUSED_GS    (1.6)   /* when printed by the music */
#define ATEND_GS        (2.0)   /* when printed at the end of the song */

#define NO              (0)
#define YES             (1)

/* the "used" field in input SSVs uses the following in addition to YES/NO */
#define UNSET           (2)

#ifndef PI
#define PI      (3.141592653589793)
#endif

#define CMPERINCH       (2.54)          /* centimeters per inch */

/*
 * Define miscellaneous macros =============================================
 */

/* number of elements in an array */
#define NUMELEM(a)      (sizeof(a) / sizeof((a)[0]))

/*
 * Define macros for allocating structures.
 */
#define MALLOC(structtype, new_p, numelem) {                            \
        if ((new_p = (struct structtype *)malloc((unsigned)             \
                        (((numelem) == 0 ? 1 : (numelem)) *             \
                        sizeof(struct structtype)))) == 0)              \
                l_no_mem(__FILE__, __LINE__);                           \
}
#define CALLOC(structtype, new_p, numelem) {                            \
        if ((new_p = (struct structtype *)calloc(                       \
                        (numelem) == 0 ? 1 : (numelem),                 \
                        (unsigned)sizeof(struct structtype)))  == 0)    \
                l_no_mem(__FILE__, __LINE__);                           \
}
#ifndef __STDC__
#define REALLOC(structtype, new_p, numelem) {                           \
        if ((new_p = (struct structtype *)realloc((char *)(new_p),      \
                        (unsigned)(((numelem) == 0 ? 1 : (numelem)) *   \
                        sizeof(struct structtype)))) == 0)              \
                l_no_mem(__FILE__, __LINE__);                           \
}
#else
#define REALLOC(structtype, new_p, numelem) {                           \
        if ((new_p = (struct structtype *)realloc((void *)(new_p),      \
                        (unsigned)(((numelem) == 0 ? 1 : (numelem)) *   \
                        sizeof(struct structtype)))) == 0)              \
                l_no_mem(__FILE__, __LINE__);                           \
}
#endif

/*
 * Define macros for allocating other arrays.
 */
#define MALLOCA(type, new_p, numelem) {                                 \
        if ((new_p = (type *)malloc((unsigned)                          \
                        (((numelem) == 0 ? 1 : (numelem)) *             \
                        sizeof(type)))) == 0)                           \
                l_no_mem(__FILE__, __LINE__);                           \
}
#define CALLOCA(type, new_p, numelem) {                                 \
        if ((new_p = (type *)calloc((numelem) == 0 ? 1 : (numelem),     \
                        (unsigned)sizeof(type)))  == 0)                 \
                l_no_mem(__FILE__, __LINE__);                           \
}
#ifndef __STDC__
#define REALLOCA(type, new_p, numelem) {                                \
        if ((new_p = (type *)realloc((char *)(new_p),                   \
                        (unsigned)(((numelem) == 0 ? 1 : (numelem)) *   \
                        sizeof(type)))) == 0)                           \
                l_no_mem(__FILE__, __LINE__);                           \
}
#else
#define REALLOCA(type, new_p, numelem) {                                \
        if ((new_p = (type *)realloc((void *)(new_p),                   \
                        (unsigned)(((numelem) == 0 ? 1 : (numelem)) *   \
                        sizeof(type)))) == 0)                           \
                l_no_mem(__FILE__, __LINE__);                           \
}
#endif

/* define macro for freeing memory */
#ifdef __STDC__
#define FREE(mem_p)     free((void *)mem_p)
#else
#define FREE(mem_p)     free((char *)mem_p)
#endif

/* convert a RATIONAL to a float */
#define RAT2FLOAT(rat)  ( (float)(rat).n / (float)(rat).d )

/* the usual minimum and maximum macros */
#define MAX(a, b)       ( (a) > (b) ? (a) : (b) )
#define MIN(a, b)       ( (a) < (b) ? (a) : (b) )

/* absolute value of the difference of a and b */
#define ABSDIFF(a, b)   ( (a) > (b) ? (a) - (b) : (b) - (a) )

/* even and odd numbers (positive, zero, or negative; works on any compiler) */
#define EVEN(a)         (abs(a) % 2 == 0)
#define ODD(a)          (abs(a) % 2 == 1)

#define SQUARED(x)      ((x) * (x))
#define NEARESTQUARTER(x) ( (int)((x) * 4.0 + 0.5) / 4.0 )

/* half the height of a staff in stepsizes; use 1 for 1-line staffs */
#define HALFSTAFF(s)    ((svpath(s, STAFFLINES)->stafflines == 5) ? 4 : 1)

/* given ptr to a group, return the NOTE struct for note nearest to the beam */
#define BNOTE(gs_p)     \
        (gs_p)->notelist[ (gs_p)->stemdir == UP ? 0 : (gs_p)->nnotes - 1 ]

/*
 * Define indices into GRPSYL.notelist for the first (FNNI) and last (LNNI)
 * non-cross-staff-stemmed notes.  Also define indices for the first (FCNI)
 * and last (LCNI) cross-staff-stemmed notes.
 *
 * For FNNI and LNNI to work, there must be non-CSS notes, although even if
 * not, it's still okay to have loops like 
 *      for (n = FNNI(gs_p); n <= LNNI(gs_p); n++)
 * and the NNN macro, which uses them, always works.
 *
 * LCNI and FCNI only work if there are CSS notes.
 */
#define FNNI(gs_p)      ((gs_p)->stemto == CS_ABOVE ?   \
                        (gs_p)->stemto_idx + 1 : 0)
#define LNNI(gs_p)      ((gs_p)->stemto == CS_BELOW ?   \
                        (gs_p)->stemto_idx - 1 : (gs_p)->nnotes - 1)
#define FCNI(gs_p)      ((gs_p)->stemto == CS_ABOVE ?   \
                        0 : (gs_p)->stemto_idx)
#define LCNI(gs_p)      ((gs_p)->stemto == CS_BELOW ?   \
                        (gs_p)->nnotes - 1 : (gs_p)->stemto_idx)

/* define the Number of Normal Notes (non-CSS notes) in a group */
#define NNN(gs_p)       (LNNI(gs_p) - FNNI(gs_p) + 1)

/* test whether the note given via the index is CSS */
#define IS_CSS_NOTE(gs_p, idx)  (                                       \
        (((gs_p)->stemto == CS_ABOVE && idx <= (gs_p)->stemto_idx) ||   \
         ((gs_p)->stemto == CS_BELOW && idx >= (gs_p)->stemto_idx))     \
)

/* test whether any CSS notes that exist would be on stem side of the group */
#define STEMSIDE_CSS(gs_p)                                      \
        ((gs_p)->stemto == CS_ABOVE && (gs_p)->stemdir == UP || \
         (gs_p)->stemto == CS_BELOW && (gs_p)->stemdir == DOWN)

/*
 * Define CSS_STEPS to be an offset to be applied to "stepsup" when the note is
 * on the other staff.  It needs to be at twice as big as the interval between
 * the highest and lowest notes so that stepsup plus or minus half of it  will
 * become a value that it could never be for a normal note (see doacc()), and
 * it has to be an even number, because, for example, that matters for vertical
 * dot placement.
 */
#define CSS_STEPS       (MAXHAND * 2)

/* is this FEED followed by a CLEFSIG (music), not a block? */
#define IS_CLEFSIG_FEED(mll_p) ((mll_p)->str == S_FEED && \
                (mll_p)->next != 0 && (mll_p)->next->str == S_CLEFSIG)

/*
 * This macro is to be used as in this example:
 *      extern int func P((int parm1, float parm2));
 * The ANSI version will result in a function prototype.  The other version
 * will result in a function declaration (no parameters).
 */
#ifdef __STDC__
#define P(parms)        parms
#else
#define P(parms)        ()
#endif

#endif