Import upstream version 5.3.

[mup] / mup / mup / structs.h

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

#ifndef _STRUCTS
#define _STRUCTS

#include <stdio.h>
#include "defines.h"
#include "rational.h"

/*
 * Define a structure for holding coordinates as input.  These are always
 * relative to something, either a real object, _page (the whole sheet of
 * paper), _win (this context's window: header, footer, or center region),
 * or _cur (the current position).
 *
 * Both the horizonal and vertical elements have a pointer to some
 * object's coordinates, and a type, which tells what part of the object is
 * to be used.  The type is RX (relative X), AE (absolute east), etc.  For
 * horizontal this would be one of [RA][XEW].  For y this would be one
 * of [RA][YNS].  Both hor and vert also have a fixed offset that is to be
 * added in (could be 0), measured in step sizes.  Finally, hor also has a
 * counts value, which translates to a width, based on the 13th coordinate
 * (INCHPERWHOLE) of the thing this structure is attached to.  This field is
 * not allowed in headers and footers.
 */
struct INPCOORD {
	float *hor_p;
	short htype;
	float hsteps;
	float counts;

	float *vert_p;
	short vtype;
	float vsteps;
};

/*
 * We save a linked list of the addresses of tag references, so that if a tag
 * is moved, we can update its references.
 */
struct COORD_REF {
	float **ref_p_p;		/* address of tag reference */
	struct COORD_REF *next;		/* for linked list */
};

/*
 * For each coodinate that is pointed to by some location variable, we
 * need a bunch of information about it, such as whether it's from a NOTE,
 * BAR, builtin variable, or GRPSYL. If not a builtin varaible, we'll need
 * to know what page, score, and (if GRPSYL) staff, it is associated with
 * in order to figure out how to split things that end up on different
 * scores and/or pages.
 */
struct COORD_INFO {
	float *coordlist_p;		/* address of the coordinate */
	short flags;			/* if CT_NOTE, CT_BAR, etc */
	short page;			/* which page it's on */
	short scorenum;			/* which score on the page */
	short staffno;			/* which staff (CT_GRPSYL only) */
	struct MAINLL *mll_feed_p;  /* the feed info about the score it's on */
	struct BAR *pseudo_bar_p;	/* if this is a CT_BAR that happens
					 * to fall at the end of a score,
					 * this field will contain a pointer
					 * to the pseudo bar at the beginning
					 * of the following score */
	struct COORD_REF *ref_list_p;	/* list of references to this coord */
	struct COORD_INFO *next;	/* linked list off hash table */
};

/*
 * Define a structure to be used to hold two staff numbers, and pointers
 * to strings to be malloc'ed to hold labels, if desired.  This is to
 * be used for brace and bracket info.
 */
struct STAFFSET {
	short topstaff;		/* first staff joined by brace or bracket */
	short botstaff;		/* last staff joined by brace or bracket */
	char *label;		/* label to be used on first score */
	char *label2;		/* label to be used on later scores */
};

/*
 * Define a structure to be used to hold top and bottom of a range of staffs
 */
struct TOP_BOT {
	short top;
	short bottom;
};

/*
 * Define headcell structure pointing off at linked list of structures
 * holding information about an instance of one of the contexts of the
 * C_BLOCKHEAD class.
 */
struct BLOCKHEAD {
	struct PRINTDATA *printdata_p;	/* point at first item in list */
	float c[NUMCTYPE];		/* for _win */
	float height;			/* of the context instance in inches */
};

/*
 * Define a structure for the above linked list, holding information
 * about printing.  Can also be on a list off of a PRHEAD struct.
 */
struct PRINTDATA {
	struct INPCOORD location;	/* input coordinates */
	float width;			/* of string in inches */
	short justifytype;		/* J_LEFT, etc. */
	char *string;			/* malloc'ed string to print */
	short isPostScript;		/* is this for raw PostScript? */
	char *inputfile;        	/* file this print command came from */
	short inputlineno;      	/* line number in inputfile */
	struct PRINTDATA *next;		/* for linked list */
};

/*
 * Information about the size of each character in FONTFACTORs of an inch.
 * Note that we don't explicitly store descent; it is (height - ascent).  Also
 * info is only stored about the size of DFLT_SIZE characters; those in other
 * sizes are assumed to be proportional.
 */
struct FONTINFO {
	short	ch_width[CHARS_IN_FONT];
	short	ch_height[CHARS_IN_FONT];
	short	ch_ascent[CHARS_IN_FONT];
	char	*ps_name;	/* PostScript name of font */
	FILE	*fontfile;	/* User's PostScript defn of font, if any  */
	short	is_ital;	/* is this an italic font? */
};

/* mapping of user names for non-ascii characters to internal code numbers */
struct SPECCHAR {
	char *charname;		/* name user would use inside \(  )  */
	short code;		/* internal code, like the ASCII code would
				 * be for a text font */
};

/*
 * Store info about a string, for tablature.  The parse phase fills in an array
 * of these, one for each string, for each tablature staff.
 */
struct STRINGINFO {
	char letter;		/* 'a' to 'g' */
	char accidental;	/* '\0', '#', '&' */
	short nticks;		/* 0 or more */
	short octave;		/* MINOCTAVE to MAXOCTAVE */
};

/*
 * Define structure holding information about these three contexts:
 *
 *	score		the whole score
 *	staff		a staff
 *	voice		a voice
 *
 * Every field used by voice is also used by staff and score.  Every field
 * used by staff is also used by score.
 *
 * Except for the selector and "used" fields, every field is numbered.
 * Each item in the map "used" tells whether the corresponding field is
 * currently being used in this instance of the structure.  Fields that are
 * always set at the same time may be numbered as a group.
 *
 * Instances of this structure are used in two ways.
 *
 * First, whenever the user's input contains a context of score, staff, or
 * voice, a "struct MAINLL", which contains one of these structures, is
 * allocated and put in the main linked list.  For each item the user sets,
 * the corresponding field is set in this structure and its "used" bit is
 * set to YES.  If the user sets a parameter during the course of the input for
 * a voice, using the <<....>> construct, the SSV will be put in a TIMEDSSV
 * structure and linked off the following BAR line.
 * 
 * Second, a structure is allocated statically (global variable) for each
 * possible score, staff, and voice.  Each time the program scans through
 * the main linked list, it starts off by populating the (one and only)
 * score structure with default values for everything, and setting all its
 * "used" bits to YES.  It sets all the "used" bits for the staff and voice
 * structures to NO.  As it scans through the main linked list, whenever it
 * finds one of these structures, it copies all the fields whose "used" bits
 * are YES in that structure, to the appropriate fixed structure, and sets
 * its "used" bit to YES there.  The selector and linkage items are not used
 * in these fixed structures.
 * 
 * Whenever the program needs to know the current value of a field for a
 * given voice, staff, and score, it uses a viewpath through the corresponding
 * three fixed structures, in that order, using the "used" bits to see if
 * the field is filled in.  Note that the score structure is always fully
 * populated, so the info will be found then, if not earlier.
 */

/* define the indices to the "used" field */
#include "ssvused.h"

struct SSV {
	/* ======== SELECTOR ITEMS (ONLY SET FOR USER INPUT STRUCTS) ======= */
	short context;	/* which context is it for? (used by all) */
	short staffno;	/* staff no. (used by staff & voice); 1 to MAXSTAFFS */
	short voiceno;	/* voice no. (used by voice); 1 to MAXVOICES */

	/* ======== USED FLAGS ======== */
	char used[NUMFLDS];	/* map of which fields below are being used */

	/* ======== ITEMS FOR SCORE CONTEXT ONLY ======== */
	float scale_factor;	/* scale the whole output by this amount */

	float units;		/* INCHES or CM */

	float pageheight;	/* size of the paper, in inches */
	float pagewidth;

	short panelsperpage;	/* print how many panels on each page of paper*/

	float topmargin;	/* the four margins, in inches */
	float botmargin;
	float leftmargin;
	float rightmargin;

	short restcombine;	/* min. no. of mr to combine, like -c option */
	short firstpage;	/* page number for first page, like -p option*/

	short staffs;		/* no. of staffs, 1 to MAXSTAFFS */

	/*
	 * The following vertical distances are in units of stepsizes.
	 * They are as follows:  minscsep is the smallest distance ever allowed
	 * between the bottom line of the bottom staff of one score, and the
	 * top of the top of the next.  (The program distributes extra space
	 * on the page between scores.)  maxscsep is the farthest distance
	 * allowed here, unless things sticking out force it farther.
	 * scorepad is the mininum distance allowed between the outermost
	 * things on neighboring scores.
	 */
	short minscsep;
	short maxscsep;
	short minscpad;
	short maxscpad;

	/*
	 * A brace scheme is either "none" (nbrace == 0), or a list of pairs
	 * of staff numbers and optional labels.  Braces are to be drawn
	 * joining each pair of staffs at the start of each score.  The staffs
	 * in a pair may be the same; (3,3) means a brace is put on staff 3.
	 * If nbrace != 0, an array must be malloc'ed for bracelist to point
	 * at, so it can be treated as an array.  If labels are to be printed
	 * for the group of staffs, a place must be malloc'ed for them, and
	 * the pointers in the "struct STAFFSET" must be set.  Otherwise,
	 * those pointers must be set to null.
	 *
	 * A bracket scheme works exactly the same, using nbrack and bracklist.
	 * 
	 * Barcon refers to which staffs are to be connected by bar lines.
	 * This also works the same way, except that if staff N does not
	 * fall within any of the ranges, it still will have bar lines, as
	 * if (N,N) had been listed explicity.  Also, no labels are allowed.
	 */
	short nbrace;			/* brace ranges in list */
	struct STAFFSET *bracelist;	/* pointer to list */
	short nbrack;			/* bracket ranges in list */
	struct STAFFSET *bracklist;	/* pointer to list */
	short nbarst;			/* bar-connected ranges in list */
	struct TOP_BOT *barstlist;	/* pointer to list */

	/* 
	 * Common and cut time are noted as such in timetype, but in all other
	 * ways are treated as 4/4 and 2/2 respectively.
	 */
	short timetype;		/* time signature type */
	short timenum;		/* time sig numerator, 1 to 99 */
	short timeden;		/* time sig denominator, power of 2 */
				/* from 1 to 64 */
	char *timerep;		/* representation of time signature */
	short timevis;		/* is time sig visible (YES or NO) */
	RATIONAL time;		/* time signature in lowest terms */

	short division;		/* clock ticks per 1/4 note (used by midi) */
	short endingstyle;	/* where ending brackets are to be drawn */
	short gridsatend;	/* print chord grids at end of song? */
	short measnum;		/* should measure numbers be printed? */
	short measnumfamily;	/* font family for measnum */
	short measnumfont;	/* font for measnum */
	short measnumsize;	/* point size for measnum */
	float packfact;		/* horizontal packing factor */
	float packexp;		/* horizontal packing expansion (exponent) */

	short warn;		/* should warnings be printed (YES/NO)? */

	/* ======== ITEMS FOR SCORE AND STAFF CONTEXT ======== */
	float staffscale;	/* scale staff by this, relative to score */
	short stafflines;	/* number of lines in staff (normally 5) */
	struct STRINGINFO *strinfo;	/* iff tab staff, malloc'ed array */
	short printclef;	/* SS_* (shares staffline's "used" flag) */
	short gridswhereused;	/* print grids by chords where used? */
	float gridscale;	/* scale chord grids by this times staffscale*/
	short gridfret;		/* min fret to print next to chord grid */
	short numbermrpt;	/* should mrpt have number printed above? */
	short printmultnum;	/* should multirests have no. printed above? */
	short restsymmult;	/* draw multirests using rest chars? (YES/NO)*/
	short vscheme;		/* voice scheme */
	short vcombine[MAXVOICES]; /* voices to be combined if possible, in the
				    * order to try the combining */
	short vcombinequal;	/* vcombine qualifer (see definition of VC_*) */
	short sharps;		/* no. of sharps, -7 to 7 */
	short is_minor;		/* minor key (YES/NO)? (used by MIDI) */
	short cancelkey;	/* should old key sig be canceled with nats? */
	short inttype;		/* transpose: interval type (MINOR, ...) */
	short intnum;		/* transpose: interval number, neg means down*/
	short addinttype;	/* same as inttype but for addtranspose */
	short addintnum;	/* same as intnum but for addtranspose */
	short clef;		/* which clef is it? */
	short rehstyle;		/* what should reh marks be enclosed in? */
	short fontfamily;	/* font family for text other than lyrics */
	short font;		/* font for text other than lyrics */
	short size;		/* point size for text other than lyrics */
	short lyricsfamily;	/* font family for lyrics */
	short lyricsfont;	/* font for lyrics */
	short lyricssize;	/* point size for lyrics */
	float lyricsalign;	/* fraction of syl to the left of chord center*/
	short sylposition;	/* points left of chord center to start syl
				 * (overrides lyricsalign if used) */

	/*
	 * minstsep is the distance between bottom line of this staff and top
	 * line of the first visible staff below it, unless things sticking out
	 * force them to be farther apart.
	 */
	short minstsep;

	/*
	 * staffpad is the mininum distance allowed between the outermost
	 * things on neighboring staffs.  It can be negative, to allow
	 * overlapping.
	 */
	short staffpad;

	/*
	 * markorder, for each "place", contains the stacking priority of each
	 * MK_* (mark type).  Priority 1 get stack first, then 2, etc.  This
	 * should really be "short" (a number, not a char), but it would waste
	 * too much space.
	 */
	char markorder[NUM_PLACE][NUM_MARK];

	short pedstyle;		/* type of pedal marks to draw */
	short chorddist;	/* min dist between chord & staff, STEPSIZEs */
	short dist;		/* min dist between stuff & staff, STEPSIZEs */
	short dyndist;		/* min dist between dyn & staff, STEPSIZEs */

	/* must malloc a place to store these strings, else set to null */
	char *label;		/* label on first score */
	char *label2;		/* label on later scores */

	/* ======== ITEMS FOR SCORE, STAFF, AND VOICE CONTEXT ======== */
	/*
	 * Although "visible" applies to score, staff, and voice, it is handled
	 * specially; see svpath() in ssv.c.  The "visible" parameter sets both
	 * the "visible" and "hidesilent" fields, as follows:
	 *	visible parameter	visible field		hidesilent field
	 *		"n"			NO			NO
	 *		"whereused"		YES			YES
	 *		"y"			YES			NO
	 * The whereused value is not allowed for voice.  As soon as the all
	 * the scorefeeds are known (after abshorz.c), new SSVs are inserted to
	 * make the appropriate staffs invisible "for real" (using "visible").
	 */
	short visible;		/* is the voice visible? */
	short hidesilent;	/* if normally visible, hide when not used? */
	/*
	 * A beam scheme is either "none" (nbeam == 0), or a list of note
	 * durations adding up to a full measure.  nbeam is how many durations
	 * in the list.  If nbeam != 0, an array must be malloc'ed for
	 * beamstlist to point at, so it can be treated as an array.
	 * Some of these durations can be parenthesized sublists of durations.
	 * If not, then nsubbeam == nbeam and subbeamstlist is the same as
	 * beamstlist.  But if so, the "sub" items count and list each
	 * individual duration, regardless of whether it's a stand-alone
	 * duration, or a member of a sublist; and nbeam and beamstlist give
	 * the combined version, where the durations of each sublist are added
	 * up and are regarded as a single duration.
	 * When nbeam != 0, beamrests tells whether the "r" flag was given;
	 * otherwise, beamrests is garbage.
	 * When nbeam != 0, beamspaces tells whether the "s" flag was given;
	 * otherwise, beamspaces is garbage.
	 */
	short nbeam;		/* durations in list */
	RATIONAL *beamstlist;	/* pointer to list */
	short beamrests;	/* YES or NO:  beam across rests? */
	short beamspaces;	/* YES or NO:  beam across spaces? */
	short nsubbeam;		/* durations in list */
	RATIONAL *subbeamstlist; /* pointer to list */

	/* these are controlled by BEAMSLOPE */
	float beamfact;		/* beam angle = this * regression angle */
	float beammax;		/* maximum beam angle allowed (degrees) */

	float pad;		/* apply on left of each group (stepsizes) */
				/* internal value = external - 1/3 */
	float stemlen;		/* stem length in inches */
	float stemshorten;	/* how much beamed stems can be shortened */
				/*  (in stepsizes) */

	short defoct;		/* default octave number, 0 to 9 */
	RATIONAL timeunit;	/* note length to use when none specified */
	struct TIMELIST *timelist_p;	/* LL of additional times for timeunit*/
	RATIONAL swingunit;	/* duration within which notes are to "swing" */
	short release;		/* internote space for MIDI, in milliseconds */
	short ontheline;	/* put notes on the one-line staff line? */
	short tabwhitebox;	/* print white rectangle under fret numbers? */
	short noteheads[7];	/* headshapes to be used for each scale degree*/
};

/*
 * Define a structure for timed SSVs.  These represent parameters that are set
 * in the course of the input for a voice, using the <<....>> construct rather
 * than being set the usual way in a score, staff, or voice context.  They are
 * put in a linked list hanging off the next BAR structure.  They are stored in
 * user input order, except that they are sorted by time_off.
 */
struct TIMEDSSV {
	struct SSV ssv;		/* all the normal contents of an SSV */
	RATIONAL time_off;	/* time offset into the measure where it is */
	struct GRPSYL *grpsyl_p;/* the group before which the <<....>> was */
	struct TIMEDSSV *next;	/* link to the next one */
};

/*
 * If the user enters times to be added together, like 2.+16, a linked list of
 * these structs keeps track of the added times.
 */
struct TIMELIST {
	int		basictime;
	RATIONAL        fulltime;	/* like fulltime in struct GRPSYL */
	struct TIMELIST *next;		/* for linked list */
};

/*
 * Define structure pointing to the list of chords in a measure.
 */
struct CHHEAD {
	struct CHORD *ch_p;	/* point at a linked list of chords */
};

/*
 * Define structure pointing a list of things to print.  It is used for
 * prints that occur in the "music" context.
 */
struct PRHEAD {
	struct PRINTDATA *printdata_p;	/* point at first item in list */
};

/*
 * Define a structure containing a coordinate for an ending or rehearsal mark.
 * The coordinate given is the south edge of the item's rectangle.
 */
struct MARKCOORD {
	short staffno;		/* which staff has the ending and/or rehear */
	float ry;		/* vertical coord rel to center line of staff */
	struct MARKCOORD *next;	/* for linked list */
};

/*
 * Define structure holding info about a bar line.
 */
struct BAR {
	short bartype;		/* type of bar line */
	short linetype;		/* type of line (L_*) */

	/*
	 * When a repeatstart occurs at the end of a line, it gets moved to the
	 * pseudobar on the next line.  Where it used to be, a new bar line is
	 * supplied.  The type of that new bar line is specified by precbartype.
	 * It defaults to singlebar.
	 */
	short precbartype;

	/*
	 * The bar line's coordinates have the following meanings.
	 * X is the middle of the bar line (even if it's a repeat sign, etc.).
	 * Y is the middle line of the top staff.
	 * W and E allow standard padding.  (The leftmost "bar line" on a score
	 * is not considered to be a bar line at all, but is just drawn as
	 * part of the score.)
	 * N is the top line of the top staff; S is the bottom line of the
	 * bottom staff.
	 */
	float c[NUMCTYPE];	/* coordinates */

	float padding;		/* extra space to allow */

	/*
	 * Define whether the user used "hidechanges" on this bar, which
	 * prevents changes of clef, key, and time from printing out after this
	 * bar if it ends up being the last bar on a score.
	 */
	short hidechanges;	/* YES or NO */

	/*
	 * Define position (*ITEM) relative to an ending, and what the label
	 * should say.  The label is meaningful only for the first bar of
	 * the ending (STARTITEM).  ENDITEM is used for the bar after the
	 * last measure of the ending.
	 */
	short endingloc;	/* position within (or not) an ending */
	char *endinglabel;	/* malloc'ed string to label the ending */

	short reh_type;		/* REH_* */
	char *reh_string;	/* string to print as rehearsal mark; should */
				/* be null if reh_type != REH_STRING */
	short dist;		/* overrides SSV dist for the reh mark */
	short dist_usage;	/* was dist used, and was it forced? (SD_*) */

	short mnum;		/* measure number, 0 unless set by the user */

	/*
	 * These start linked lists, one structure for each staff at this
	 * bar line that needs to have coordinates stored for an ending mark
	 * or a rehearsal mark above it.  A coord is given for an ending
	 * mark only at the bar line where it begins.
	 */
	struct MARKCOORD *ending_p;	/* LL for ending marks */
	struct MARKCOORD *reh_p;	/* LL for rehearsal marks */

	/*
	 * There is also a linked list holding SSVs for parameters that were
	 * set during the input for a voice rather than in their own context.
	 */
	struct TIMEDSSV *timedssv_p;
};

/*
 * Define structure for a line.
 */
struct LINE {
	short linetype;			/* type of line */
	struct INPCOORD start, end;	/* start and end points */
	char *string;			/* malloc; to be printed by the line */
};

/*
 * Define structure for a curve.  There are two input formats for a curve.  The
 * first type gives 3 or more coordinates, but no bulge distances.  For that
 * type ncoord tells how many coordinates, the coordinates are given by
 * coordlist, nbulge is zero, and bulgelist is not allocated.  For the other
 * type of curve, 2 points (the endpoints) are given, and 1 or more bulge
 * distances are given, in stepsize units.
 */
struct CURVE {
	short curvetype;		/* type of curve */
	short ncoord;			/* number of coords in the following */
	struct INPCOORD *coordlist;	/* array of coords to be malloc'ed */
	short nbulge;			/* number of bulge distances given */
	float *bulgelist;		/* array of them to be malloc'ed */
};

/*
 * Define a structure for score and page feeds.  The parser puts these in
 * the main linked list when it sees the user's "newscore" and "newpage"
 * directives, and the placement phase puts additional ones there as needed.
 */
struct FEED {
	short pagefeed;		/* YES=score & page feed, NO=scorefeed only */

	/* the following are set to -1.0 when they aren't being used */
	float leftmargin;	/* override param on score after the feed */
	float rightmargin;	/* override param on score before the feed */

	/*
	 * If this is a pagefeed, there may be blockhead contexts of some or
	 * all of these four types that we need to point at.  When the user
	 * uses one of these contexts, it forces a pagefeed (whether they
	 * explicitly requested it or not), and the parse phase sets the
	 * pointer to a malloc'ed area.  Later, in absvert.c, these pointer
	 * values are carried forward to subsequent pagefeeds.
	 */
	struct BLOCKHEAD *top_p, *top2_p, *bot_p, *bot2_p;

	short firstvis;		/* first visible staff number in this score */
	short lastvis;		/* last visible staff number in this score */
	float lastdist;		/* distance from bottom line of last visible */
				/*  staff to the southernmost extent of score*/

	/*
	 * The following are the coordinates of the score that follows.
	 * W and E are the margins, which it always extends out to when you
	 * consider labels and everything (no padding).
	 * N and S are just far enough out to include every rectangle,
	 * every staff, and every clef, with standard padding.
	 * X is the the X of the line left of the clefs.
	 * Y is the middle line of the top visible staff.
	 */
	float c[NUMCTYPE];	/* coordinates of the score that follows */
};


/*
 * Define structure telling whether to print clef, key signatures, or
 * time signatures.
 */
struct CLEFSIG {
	short prclef[MAXSTAFFS + 1];	/* print clef this staff? (YES/NO) */
	short clefsize;			/* print them DFLT_SIZE or SMALLSIZE */
	/*
	 * sharps tells how many sharps to print in the key sig.  If negative,
	 * it means flats.  naturals means how many sharps are to be cancelled
	 * with natural signs.  If negative, it means we are cancelling flats.
	 * Based on these numbers and on music theory, the print phase knows
	 * which ones to print.  If both are zero, no key sig is to be printed.
	 */
	short sharps[MAXSTAFFS + 1];
	short naturals[MAXSTAFFS + 1];
	short prtimesig;		/* print time signature? (YES/NO) */
	float wclefsiga;		/* absolute west coord of clefsig */
	float effwidth;			/* width that can't overlap chords */
					/* (used only by user clefsigs) */
	float widestclef;		/* width of widest clef to print */
					/* (used only by user clefsigs) */
	short hide;			/* should be hidden (hidechanges)? */
	short multinum;			/* number of measures in the multirest
					 * that follows, 0 if no multirest */

	/*
	 * The following is a pointer to a BAR that gets malloc'ed for
	 * CLEFSIGs that occur after FEEDs (at the start of a score).  This
	 * represents the special, pseudo bar line at the start of a score.
	 * This pseudo bar comes immediately after the other clefsig items.
	 * It actually gets drawn only if it happens to be a REPEATSTART.
	 */
	struct BAR *bar_p;
};


/*
 * Define a structure describing a staff for one measure, which points off to
 * linked lists of GRPSYLs and STUFFs.
 */
struct STAFF {
	short staffno;			/* staff number */
	short visible;			/* is this staff visible? */

	/*
	 * Coordinates for the location of the staff.  The relative horizontal
	 * ones are never set, but the absolute horizonal ones are set to meet
	 * the surrounding bar lines.  The vertical ones are the same for
	 * all STAFFs for the same staff number for a given score.  (For each
	 * staff number, the packing of rectangles is done across the whole
	 * score, and the same resulting vertical coords are stored in each
	 * measure's STAFF.)  The relative vertical coords start out relative
	 * to the center line of the staff, so at that time RY is 0.  Later,
	 * they are changed to be relative to the score.
	 */
	float c[NUMCTYPE];		/* location of staff */

	struct GRPSYL *groups_p[MAXVOICES]; /* linked list(s) of voices */

	/*
	 * Following is syls_p, a malloc'ed array of headcells of linked lists
	 * of GRPSYLs for verses.  There are "nsyllists" lists, which is
	 * "Maxverses" or less.  The parallel array sylplace tells whether
	 * each list of syllables is above this staff, below it, or centered
	 * between this staff and the next staff number.  The verse numbers do
	 * not have to equal the index into syls_p.  Lists for the three
	 * places can be mixed together, alternating or whatever.  But the
	 * verse numbers of each given place are in increasing order.  Any
	 * verses may be missing, but then they won't have entries in syls_p.
	 */
	short nsyllists;
	short *sylplace;
	struct GRPSYL **syls_p;

	/*
	 * Following is the headcell for the linked list of other "stuff"
	 * associated with this staff; above, below, and between mixed together
	 * any which way.  Actually, they are in user input order for below,
	 * and reversed for above and between, and that's the order in which
	 * their surrounding rectangles will be packed together.  Thus, on the
	 * page things will end up placed in agreement with user input order.
	 */
	struct STUFF *stuff_p;

	/*
	 * Centered between this staff and the next we may have lyrics and/or
	 * "stuff".  The rectangles for all this are packed together against
	 * a base line, and then the total height of all that is stored here.
	 */
	float heightbetween;

	/*
	 * In an mrpt measure, this holds the number that is to be printed
	 * above the measure (2 at the first mrpt, then increment).  For other
	 * measures it is 0.
	 */
	short mrptnum;
};


/*
 * Define a structure that hold information about a chord grid.
 */
struct GRID {
	char *name;		/* internal chord name string (malloc) */

	/*
	 * positions[0] is the fret for the first string, positions[1] is the
	 * second, etc.  0 means draw an "o" above this string, -1 means draw
	 * an "x".  -2 means draw nothing.
	 */
	short positions[MAXTABLINES];	/* slot for each string possible */
	short numstr;			/* number of strings used */

	/*
	 * Numbers of the left and right strings to which the curved line
	 * extends.  The first string is 1, not 0.  0 means no curved line.
	 */
	short curvel, curver;

	short used;			/* was this grid used in this song? */
};


/*
 * Define a structure that describes an item to be drawn other than music and
 * lyrics.  A linked list of these can hang off a STAFF structure.
 */
struct STUFF {
#ifdef BIGMEM	/* the way we'd define things, if we had plenty of memory */

	short inputlineno;	/* which input line this structure came from */
	char *inputfile;	/* which file this came from (malloc'ed) */
	char *string;		/* usual convention of 1st 2 bytes = font/size*/
	short all;		/* does this STUFF actually belong to "all" */
				/* (the score), not a particular staff? YES/NO*/

	/*
	 * Define start and end times for the stuff.  "start" and "end.count"
	 * range from 0 to (numerator_of_time_sig + 1).  They can be any float
	 * within that range; they don't have to line up with any group.
	 * However, if gracebackup is not 0, it means the stuff is to start at
	 * that many grace notes before the normal group that is closest to
	 * "start".  Also, if the stuff is a phrase mark, both ends of it are
	 * set to the nearest group that is not rest or space, even if grace-
	 * backup is 0.  (If it is nonzero, it then works the same way.)
	 * In any case, after the start position is determined as described
	 * above, the "steps" offset is applied to it, which can be positive,
	 * negative, or (usually) zero.
	 */
	struct {
		float count;	/* counts into measure where the thing begins*/
		float steps;	/* offset in stepsizes */
	} start;
	struct {
		int bars;	/* how many bar lines it crosses */
		float count;	/* count (in whichever measure) where it ends */
	} end;			/* both are 0 if no "til" clause */
	short gracebackup;	/* how many graces before "start" to start at */

	short stuff_type;	/* ST_CRESC, etc. */
	short modifier;		/* if text, is it chord, etc. (TM_*)? */
				/* if phrase, what type of line (L_*)? */
	short place;		/* PL_ABOVE, etc. */
	short dist;		/* overrides SSV dist/chorddist/dyndist */
	short dist_usage;	/* was dist used, and was it forced? (SD_*) */
	short carryin;		/* is this a continuation from last score? */
	short carryout;		/* does this continue onto the next score? */
	struct STUFF *costuff_p;/* for tie/slur/bend carryin stuff, point at 
				 * corresponding carryout stuff */

	/*
	 * The following group of variables is used only for ST_PHRASE and/or
	 * ST_TIESLUR.
	 *
	 * Phrases use them as follows:
	 * A phrase must be assigned to apply to a particular voice on the
	 * staff.  Unlike other STUFF, the endpoints of a phrase mark need to
	 * get associated with GRPSYLs.  These pointers get set to point at
	 * them.  If it crosses score feeds, carry ins and outs will have a
	 * pointer to the first and last GRPSYL of the score, respectively.
	 * The crvlist_p is the headcell of the linked list of points forming
	 * a phrase mark.  begnote_p is not used.
	 *
	 * Ties and slurs use them as follows:
	 * A tie/slur is not input the same as other STUFF.  The user's input
	 * sets its starting note.  The STUFF structure is not allocated until
	 * stuff.c.  At that point, vno, beggrp_p, and begnote_p are set, and
	 * crvlist_p is set up like for phrases.  If it crosses a scorefeed,
	 * carry in and out are used, and the "beg" pointers for the second
	 * half of the tie/slur point at the end group and note.  In any case,
	 * curveno tells which tie/slur this STUFF refers to, since a tie and
	 * multiple slurs can start at the same note.  endgrp_p isn't used.
	 */
	short vno;			/* voice phrase applies to (1 or 2) */
	struct GRPSYL *beggrp_p;	/* beginning GRPSYL */
	struct GRPSYL *endgrp_p;	/* ending GRPSYL */
	struct CRVLIST *crvlist_p;	/* headcell of linked list of coords */
	struct NOTE *begnote_p;		/* beginning NOTE */
	short curveno;			/* idx into slurtolist; -1 for tie */

	/*
	 * For above and below stuff, the relative vertical coords are
	 * relative to the staff's center line.  For between stuff, they end
	 * up being relative to the center line of the above staff, but at
	 * first they are relative to the base line that the between stuff is
	 * piled on.  (Not used for phrase marks.)
	 */
	float c[NUMCTYPE];	/* where item is placed */

	struct STUFF *next;	/* for linked list */

#else		/* the same as above, optimized for space */

	char *inputfile;
	char *string;
	struct GRPSYL *beggrp_p;
	struct GRPSYL *endgrp_p;
	struct CRVLIST *crvlist_p;
	struct NOTE *begnote_p;
	struct STUFF *next;
	struct STUFF *costuff_p;
	float c[NUMCTYPE];
	struct {
		float count;
		float steps;
	} start;
	struct {
		float count;
		short bars;
	} end;
	short inputlineno;
	short gracebackup;
	short vno;
	short curveno;
	short dist;
	unsigned dist_usage	: 2;
	unsigned all		: 1;
	unsigned stuff_type	: 4;
	unsigned modifier	: 3;
	unsigned place		: 2;
	unsigned carryin	: 1;
	unsigned carryout	: 1;
#endif
};

/*
 * Define a structure for forming linked lists of coordinates making up the
 * curve of a phrase mark.  Each structure has the coordinates of one point.
 */
struct CRVLIST {
	float x;		/* absolute X */
	float y;		/* Y initially rel to staff, later absolute */
	struct CRVLIST *next;	/* doubly linked list */
	struct CRVLIST *prev;
};

/*
 * Define struct to save lists of staff number or vno (voice or verse) ranges.
 */
struct RANGELIST {
	short	begin;		/* first number in range */
	short	end;		/* last number in range. Must be >= begin */
	short	all;		/* is this staff no. actually "all" (the */
				/* score), not a particular staff? YES/NO */
	short	place;		/* PL_*   */
	struct RANGELIST *next;	/* for linked list */
};

/*
 * Define a struct to save a list of pairs of staff and voice range lists.
 */
struct SVRANGELIST {
	struct RANGELIST *stafflist_p;
	struct RANGELIST *vnolist_p;
	struct SVRANGELIST *next;	/* linked list */
};

/*
 * Define a structure for stating the note that a given note is slurred to.
 */
struct SLURTO {
	char letter;		/* a to g */
	short octave;		/* 0 to 9 */
	short slurstyle;	/* what type slur: L_[NORMAL|DOTTED|DASHED] */
	short slurdir;		/* should slur bulge UP or DOWN? */
};

/*
 * Define the structure for holding information concerning a note.  Much of
 * the info you might expect to be here actually applies to the whole "group",
 * and so is in the group/syllable structure below.
 * NOTE:  When adding fields to this structure, update function map1note().
 */
struct NOTE {
	/*
	 * Define the coords x, y, north, south, east, west, both relative
	 * and absolute.  The relative coords are relative to the group's
	 * (x, y). The NSEW coords define a rectangle surrounding the note
	 * head.  XY are the center of the note head.
	 */
	float *c;		/* must malloc array; see comment in */
				/*  grpsyl.c, add_note() for why */

	float waccr;		/* relative coord:  w(accidental)-x(group) */
	float ydotr;		/* relative coord:  y(dot)-y(group) */

	/* these next two are used when note_has_paren is YES */
	float wlparen;		/* relative coord:  w(left paren)-x(group) */
	float erparen;		/* relative coord:  e(right paren)-x(group) */

	/*
	 * nslurto says how many notes of the following group this note is
	 * slurred to.  If it is greater than 0, an array of that many SLURTO
	 * structures must be malloc'ed and slurtolist set to point at it.
	 */
	struct SLURTO *slurtolist;
	short nslurto;

	char letter;		/* a to g */
	char accidental;	/* '\0', 'x', '#', 'n', '&', 'B'(double flat)*/
	short octave;		/* 0 to 9 */
	short stepsup;		/* how many steps above middle line is note? */
	char headfont;		/* music char font of this note head */
	char headchar;		/* music char number of this note head */
#ifdef BIGMEM	/* the way we'd define things, if we had plenty of memory */
	short headshape;	/* shape type of this note head */
	short notesize;		/* size of the note head */
	short tie;		/* if YES, tie this note to the same note in
				 * the next note group */
	short tiestyle;		/* what type of tie: L_[NORMAL|DOTTED|DASHED] */
	short tiedir;		/* should tie bulge UP or DOWN? */
	short acc_has_paren;	/* does the accidental have () around it? */
	short note_has_paren;	/* does the entire note have () around it? */
	short is_bend;		/* does slurto list really contain a "bend"? */

	/*
	 * On a tabnote staff, when there is a bend of <= 1/4 steps, the bent-
	 * to note isn't drawn.  Instead, smallbend is set to YES, and a small,
	 * curved line gets drawn.  In the input, the user specifies this by
	 * saying ^/ after the note.
	 */
	short smallbend;

#else		/* the same as above, optimized for space */
	unsigned notesize	: 1;
	unsigned tie		: 1;
	unsigned tiestyle	: 3;
	unsigned tiedir		: 2;
	unsigned acc_has_paren	: 1;
	unsigned note_has_paren	: 1;
	unsigned is_bend	: 1;
	unsigned smallbend	: 1;
	unsigned headshape	: 5;
#endif
};
/*
 * For tablature, the items above are used differently from the usual meaning.
 * Accidentals are never printed, so their coordinates are not used.  letter
 * is used to store the string number.  accidental is used to store the fret
 * number.  Inside the octave field three bit fields are used to store the bend
 * distance, as follows from high bits to low bits:
 *	integer part of bend; if no integer, store 0.
 *	numerator part of bend; if no fraction, store 0.
 *	denominator part of bend; if no fraction, store 0.
 *	If "full", store as if the integer 1 were given for bend (1-0-0).
 * The following macros are used for accessing these fields.  acc_has_paren is
 * used to indicate parentheses around the fret number, so an alternate name is
 * defined for it.  stepsup is used, in the parse phase only, to store number
 * of tick marks and fret values; see grpsyl.c for the details.  In later
 * phases it is set to its usual meaning, but note that middle of the staff
 * will not be a line if there are an even number of lines.
 */
#define	STRINGNO		letter
#define	FRETNO			accidental
#define	BEND			octave
#define	BENDINT(note)		(((note).BEND >> \
				(BENDNUMBITS + BENDDENBITS)) & MAXBENDINT)
#define	BENDNUM(note)		(((note).BEND >> BENDDENBITS) & MAXBENDNUM)
#define	BENDDEN(note)		(((note).BEND >> 0) & MAXBENDDEN)
#define	TABOCT(inte, num, den)	(((inte) << (BENDNUMBITS + BENDDENBITS)) | \
				((num) << BENDDENBITS) | ((den) << 0))
#define HASBEND(note)		((note).BEND != 0)
#define HASNULLBEND(note)	((note).BEND == 1)
#define HASREALBEND(note)	(HASBEND(note) && ! HASNULLBEND(note))
#define FRET_HAS_PAREN		acc_has_paren
/*
 * During parsing, we temporarily save nticks and fret in the stepsup field.
 * Bits 0-8 hold the fret, bits 9-12 hold the nticks.  Any changes to MAXFRET
 * or MAXTICKS would have to be coordinated here.  These things are stored
 * temporarily in these fields since when we are doing parsing, we still need
 * to remember the pitch and accidental information, so can't put them in their
 * final place till a bit later.
 */
#define TMP_SAVE(note_p, nticks, fret)  \
		(note_p)->stepsup = (((nticks) & 0xf) << 8) | ((fret) & 0xff)
#define TMP_NTICKS(note_p)	(((note_p)->stepsup >> 8) & 0xf)
#define TMP_FRET(note_p)	((note_p)->stepsup & 0xff)

/*
 * Define the structure for holding information concerning a "group", which
 * consists of either a space, a rest, or a list of notes stemmed together
 * (or which would be stemmed together if they were shorter than whole notes);
 * or a syllable of lyrics.
 * NOTE:  When adding fields to this structure, update function map1note().
 */
struct GRPSYL {
#ifdef BIGMEM	/* the way we'd define things, if we had plenty of memory */

	/* ======== ITEMS FOR GROUPS AND SYLLABLES ======== */
	short inputlineno;	/* which input line this structure came from */
	char *inputfile;	/* which file this came from (malloc'ed) */
	short staffno;		/* staff number */
	short vno;		/* voice (1 to MAXVOICES) or verse number */
	short grpsyl;		/* is it group or syllable? */

	/*
	 * Define the coords x, y, north, south, east, west, both relative
	 * and absolute.  The vertical relative coords are relative to the
	 * center line of the staff.  The horizontal relative coords are
	 * relative to the chord's x.  The NSEW coords define a rectangle
	 * surrounding the group; for groups, X goes through the center of
	 * the (normal) note heads; Y is the middle line of the staff.
	 * For syllables, Y is the baseline and X is the place that should
	 * line up with the chord, which is part way from the left edge toward
	 * the right edge based on lyricsalign, not counting any characters in
	 * <angle brackets> that precede or follow the real syllable.
	 *
	 * WARNING:  for groups, during the time when positions of phrase
	 * marks are being figured out, AN and AS are used in a strange way,
	 * denoting the offset from RN or RS where the phrase is.  But later
	 * they get set to their normal values.
	 */
	float c[NUMCTYPE];	/* coordinates */

	/*
	 * The basic time value is one of the following: -1, 0, power of 2 from
	 * 1 to 256, or less than -1.  For normal (is_meas==NO) groups, -1
	 * means quadruple whole, 0 means double whole, 1 is whole, 2 is half,
	 * etc.  Less than -1 means a multirest of (-basictime) measures.  For
	 * is_meas==YES groups, basictime is the same as the preceding for
	 * measure rests, where it just tells which rest to draw, but for ms
	 * and mrpt it is arbitrarily set to -1.
	 */
	short basictime;

	/*
	 * is_meas tells whether an "m" was used with the time in the input.
	 * This is used for "measure" rests, spaces, or repeats (mr, ms, mrpt).
	 * (Only mr can have a normal time value in addition to the "m"; it is
	 * stored as the basictime (defaults to 1) and tells which rest to
	 * draw.)  Their fulltime is the time signature.  mr and mrpt are
	 * centered in the measure.
	 */
	short is_meas;

	short dots;		/* number of dots applied to time value */

	short tuploc;		/* none, start, inner, end, lone (for tuplet) */
	short tupcont;		/* number to print for the tuplet */

	/*
	 * Full time is basic time modified by dots, tuplets, etc.  It's the
	 * actual time duration, and thus for grace it's always 0.
	 */
	RATIONAL fulltime;

	float padding;		/* extra space to allow */

	/* ======== ITEMS FOR GROUPS ONLY ======== */
	short pvno;		/* pseudo voice number: normally equals vno,
				 * but when voice 3 is treated like voice 1 or
				 * or 2, that number is stored here */
				/* also used as scratch area in mkchords.c */
	short grpcont;		/* note(s), rest, or space; although normally
				 * meaningful only for groups, gram.y uses it
				 * as scratch while processing syllables */
	short grpvalue;		/* normal time value; or zero for grace group
				 * or for all-space chords in MIDI */
	short grpsize;		/* size of items in group */
	short headshape;	/* default shape of noteheads in group */
	short uncompressible;	/* is this space a "us" (used for space only)*/

	short beamloc;		/* none, start, inner, end (only note groups)*/
	float beamslope;	/* user specified angle of beam in degrees */

	/*
	 * Stem length applies to groups shorter than a whole note and groups
	 * joined by "alternation" beams.  It starts out based only on
	 * basictime and grpsize, but due to a beam or override, it could be
	 * changed.  Direction is up or down, and applies to all groups, even
	 * whole note groups (useful for figuring ties).   stemx is the
	 * horizontal position of the stem, relative to the X of the GRPSYL.
	 * These fields are valid only for note groups.
	 */
	float stemlen;
	short stemdir;		/* up or down */
	float stemx;

	/*
	 * beamto is always CS_SAME, except when this group is a notes or
	 * space group and is involved in cross staff beaming.  It then tells
	 * whether we are beamed with the staff above us or below us.  It is
	 * set for all the note and space groups on both staffs in the set.
	 * So on the top staff it's set to CS_BELOW, and on the bottom staff
	 * it's set to CS_ABOVE.
	 */
	short beamto;

	/*
	 * stemto is always CS_SAME, except when this group is a notes group
	 * and is involved in cross staff steming.  It then tells whether we
	 * are stemmed with the staff above us or below us.  When stemto is not
	 * CS_SAME, stemto_idx is an index into notelist[].  For CS_ABOVE,
	 * it indexes to the last note that is on the above staff.  For
	 * CS_BELOW, it indexes to the first note that is on the below staff.
	 */
	short stemto;
	short stemto_idx;

	/* YES if the last group in a subbeam */
	short breakbeam;

	/*
	 * printtup tells whether the user wants a tuplet number and bracket to
	 * be printed next to a note group.  If PT_NEITHER, neither will be.
	 * If PT_BOTH, both will be.  If PF_DEFAULT, at least the number will
	 * be.  The bracket will be too, unless the tuplet contains only one
	 * group, or if all the groups' beamlocs are equal to their tuplocs
	 * (the groups are already beamed as a unit).  If PT_NUMBER, the number
	 * (and only the number) will be printed.  In any case, printtup
	 * is set for each group in the tuplet.
	 *
	 * tupextend is set only for the groups of a tuplet of notes that has
	 * printtup == Y.  It is the vertical offset of where the tuplet
	 * bracket would be, from the AN or AS of the groups, as the case may
	 * be.  If the bracket would be above the groups, it is positive and
	 * relative to AN; else it is negative and relative to AS.  It is set
	 * even for the case where the bracket is not going to be printed, so
	 * that the tuplet number can still be placed as halfway between the
	 * invisible bracket's endpoints.
	 */
	short printtup;
	float tupextend;
	short tupside;		/* should number & bracket be above or below?*/

	short phraseside;	/* relevant side(s) for phrase mark space */

	/*
	 * nnotes says how many notes there are in the group.  An array of
	 * that many note structures must be malloc'ed and notelist set to
	 * point at it.  The notes are stored in order of descending pitch,
	 * regardless of the user's input ordering.  These fields are valid
	 * only for note groups.
	 * But for measure repeats (mrpt), even though they are GC_NOTES,
	 * nnotes is 0 and notelist is a null pointer.
	 */
	short nnotes;		/* no. of notes in group */
	struct NOTE *notelist;	/* list of notes in group */

	/*
	 * If tie is set to YES, all notes in the group are to be tied to
	 * corresponding notes in the following group. The "tie" flag will
	 * also be set on each individual note in its NOTE struct, but it
	 * turns out to be handy to have the whole group marked here too.
	 * This field is valid only for note groups.
	 */
	short tie;

	/*
	 * The slash_alt field is used for slashes on a group or between
	 * pairs of groups (for tremolo, or just dividing the time value of
	 * the group(s).  0 means normal group; >0 means draw that many
	 * slashes through the stem of this group (or, if basictime < 2, where
	 * the stem would have been); <0 means draw negative that many slashes
	 * between this and the next group.  This field is valid only for note
	 * groups.
	 */
	short slash_alt;

	/*
	 * On a tablature staff, when an entire group is tied to the following
	 * group, the second group normally should not be printed.  (Its
	 * corresponding tabnote group will be, though.)  This flag says not to
	 * print this group.  This is set by the parse phase when the preceding
	 * tab group is tied.  It is cleared by the placement phase after
	 * scorefeeds.
	 */
	short inhibitprint;

	/*
	 * This is used for rests only.  If not used, it is NORESTDIST.
	 * Otherwise, it is the vertical offset of the "center" of the rest
	 * (the part that normally is on the center line) from the center line.
	 * The rest is forced there.
	 */
	short restdist;

	/*
	 * These are for the user-specified horizontal offset of the group from
	 * the chord's X.  The value is in stepsizes; negative to the left, and
	 * positive to the right.
	 */
	short ho_usage;		/* HO_* */
	float ho_value;		/* value to use when ho_usage is HO_VALUE */


	/* the X positions of dots are the same for every note in the group */
	float xdotr;		/* relative coord of dots:  x(dot)-x(group) */
	/*
	 * When symbols are to be drawn "with" a group, they are stored
	 * in the list below in order, starting from the group and moving
	 * outwards.  When nwith is 0, there is no list.  Otherwise, a
	 * list must be malloc'ed and the pointer must be set to point at
	 * it.  Each item in the list is a pointer to a string, which must
	 * also be malloc'ed.  Normally, the "with" items are on the note side
	 * of the group, but if there are two voices, they might need to be
	 * put on the stem side, so normwith says which side they go on.
	 * These fields are valid only for note groups.
	 */
	short nwith;		/* no. of symbols with group */
	char **withlist;	/* list of symbols with group */
	short normwith;		/* does it go on the normal (note) end of grp?*/

	short roll;		/* where is this group in a roll, if at all? */
	short rolldir;		/* is the roll's arrow UP, DOWN, or UNKNOWN? */
				/*  (with UNKNOWN, roll is up, but no arrow) */

	short clef;		/* clef to be printed before this group */

	/* ======== ITEMS FOR SYLLABLES ONLY ======== */
	char *syl;		/* malloc a place for the syllable */
	short sylposition;	/* points left of chord's X to start syl */

	/* ======== LINKAGE ======== */
	struct GRPSYL *prev;	/* point at previous group/syl in voice/verse*/
	struct GRPSYL *next;	/* point at next group/syl in voice/verse */
	struct GRPSYL *gs_p;	/* point at next group/syl in chord */

#else		/* the same as above, optimized for space */

	RATIONAL fulltime;
	float c[NUMCTYPE];
	float padding;
	float stemlen;
	float stemx;
	float tupextend;
	float ho_value;
	float xdotr;
	float beamslope;
	char *inputfile;
	char **withlist;
	char *syl;
	struct GRPSYL *prev;
	struct GRPSYL *next;
	struct GRPSYL *gs_p;
	struct NOTE *notelist;
	short inputlineno;
	short staffno;
	short vno;
	short basictime;
	short dots;
	short tupcont;
	short pvno;
	short nnotes;
	short slash_alt;
	short nwith;
	short restdist;
	short sylposition;
	short clef;
	short headshape;
	short stemto_idx;
	unsigned ho_usage	: 2;
	unsigned is_meas	: 1;
	unsigned grpsyl		: 1;
	unsigned tuploc		: 3;
	unsigned grpcont	: 2;
	unsigned grpvalue	: 1;
	unsigned grpsize	: 1;
	unsigned uncompressible	: 1;
	unsigned beamloc	: 3;
	unsigned stemdir	: 2;
	unsigned tupside	: 2;
	unsigned phraseside	: 2;
	unsigned printtup	: 2;
	unsigned tie		: 1;
	unsigned normwith	: 1;
	unsigned roll		: 3;
	unsigned rolldir	: 2;
	unsigned inhibitprint	: 1;
	unsigned beamto		: 2;
	unsigned stemto		: 2;
	unsigned breakbeam	: 1;
#endif
};

/*
 * Define the structure for a chord.
 */
struct CHORD {
	/*
	 * Define the coords of a CHORD.  For vertical, only the absolute ones
	 * are set.  They are set the same as the FEED for this score, and they
	 * are used only for drawing bounding boxes with MUP_BB.  As for
	 * horizontal, the relative coords are relative to the score's
	 * (x, y).  Basically, west and east are set out just far enough to
	 * hold the biggest GRPSYL in the CHORD.  However, for both groups and
	 * syllables there is special code that allows parts of them to stick
	 * out, when the overlap would be harmless even if the CHORDs end up
	 * being packed tightly together.
	 */
	float c[NUMCTYPE];	/* coordinates */
	float width;		/* c[RE] - c[RW], which equals c[AE] - c[AW] */
	float fullwidth;	/* dist from c[RX] of this chord to c[RX] of */
				/*  next (or to bar line if last in measure) */

	RATIONAL starttime;	/* starting time of chord within its measure */
	RATIONAL duration;	/* duration of the chord */
	float pseudodur;	/* a function of duration; proportional to */
				/* width this chord will "deserve" */

	struct CHORD *ch_p;	/* point at next chord in list */
	struct GRPSYL *gs_p;	/* point at first group or syllable in chord */
};

/*
 * Define the structure that contains info concerning chord grids that are
 * going to be printed at the end of the song.  Only one instance of this
 * structure exists.
 */
struct ATEND_INFO {
	/* number of different grids actually used in the song */
	int grids_used;

	/*
	 * Must grid dictionary be put on a separate page, following the last
	 * page of music (because it doesn't fit with the music)?  YES or NO.
	 */
	int separate_page;

	/*
	 * This is a malloc'ed array of pointers to the grids to be printed.
	 * Placement sets it up and sorts it.
	 */
	struct GRID **grid_p;

	int grids_per_row;	/* no. of grids to print per row */
	int rows_per_page;	/* no. of rows of grids allowed on one page */
	float firstgrid_x;	/* X coord of grids in the first column */
	float firstgrid_y;	/* Y coord of grids in the first row */
	float horz_sep;		/* dist between X of neighboring grids */
	float vert_sep;		/* dist between Y of neighboring grids */
};

/*
 * Define a symbol for each structure type that can be inside a union, so
 * that we can record which member of the union is being used.
 */
#define	S_SSV		(0)
#define	S_FEED		(1)
#define	S_CLEFSIG	(2)
#define	S_PRHEAD	(3)
#define	S_CHHEAD	(4)
#define	S_STAFF		(5)
#define S_LINE		(6)
#define S_CURVE		(7)
#define	S_BAR		(8)
#define	S_BLOCKHEAD	(9)

/*
 * The following contains a union of all the structures that can occur in the
 * main linked list, set up by yyparse().
 */
struct MAINLL {
	short str;	/* which structure in the union is now being used? */
	short inputlineno; /* which input line this structure came from */
	char *inputfile;	/* which file this came from (malloc'ed) */
	union {			/* malloc'ed structures to be pointed at */
		struct SSV *ssv_p;	/* score/staff/voice context info */
		struct FEED *feed_p;	/* score and/or page feed */
		struct CLEFSIG *clefsig_p;    /* print clef and/or sigs? */
		struct PRHEAD *prhead_p;/* head of list to print things */
		struct CHHEAD *chhead_p;/* head of chord list for a measure */
		struct STAFF *staff_p;	/* staff info from data context */
		struct LINE *line_p;	/* line info */
		struct CURVE *curve_p;	/* curve info */
		struct BAR *bar_p;	/* bar line info from data context */
		struct BLOCKHEAD *blockhead_p;	/* info for a "block" context */
	} u;
	struct MAINLL *prev;	/* previous structure in linked list */
	struct MAINLL *next;	/* next structure in linked list */
};
/*
 * The structures in the main linked list must occur in the order as shown
 * below, by the end of the placement phase.  There are optional initial SSVs,
 * then two alternative sets of structures that repeat, then some optional
 * final structures.  The list shows [in brackets] which phase of Mup inserts
 * the structure:  parse or placement.  (The third phase, print, doesn't insert
 * any structures; nor does the midi phase, which can replace the print phase.)
 *
 * 0 or more SSVs [parse]
 * LOOP 1 or more times:
 *    EITHER a measure:
 *       0 or 1 FEED; 1 is required in 1st measure & after block[parse or place]
 *       0 or 1 CLEFSIG (at start of a score); 1 iff a FEED precedes [place]
 *       1 CHHEAD [place]
 *       1 or more STAFFs.  They are ordered by staff number. [parse]
 *       0 or more LINEs and/or CURVEs and/or PRHEADs, any order[parse or place]
 *       1 BAR [parse]
 *       0 or more SSVs [parse or place]
 *       0 or 1 CLEFSIG (after a bar line, not at start of a score) [place]
 *    OR a block:
 *       1 FEED [parse]
 *       1 BLOCKHEAD [parse]
 *       0 or more SSVs [parse]
 *    END_EITHER
 * END_LOOP
 * 0 or more LINEs and/or CURVEs and/or PRHEADs and 1 optional FEED; the FEED
 *			is required if a block preceeds [parse]
 */
#endif