richard/abcmidi
1
0
Fork 0
mirror of https://github.com/sshlien/abcmidi.git synced 2025-12-06 06:55:06 +00:00
Code Issues Projects Releases Wiki Activity
Files
2022.02.07
abcmidi/yapstree.c
Seymour Shlien 1105ee0c8b 2021.05.25
2021-05-26 15:50:57 -04:00

3005 lines
68 KiB
C
Raw Permalink Blame History

/*
* yaps - program to convert abc files to PostScript.
* Copyright (C) 1999 James Allwright
* e-mail: J.R.Allwright@westminster.ac.uk
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*
*/
/* yapstree.c - back-end for abc parser. */
/* generates a data structure suitable for typeset music */
#define VERSION "1.87 May 25 2021 yaps"
#include <stdio.h>
#ifdef USE_INDEX
#define strchr index
#endif
/* for Microsoft VC 6++ or higher */
#ifdef _MSC_VER
#define ANSILIBS
#define snprintf _snprintf
#endif
#ifdef ANSILIBS
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#else
char* strchr();
#endif
#include "abc.h"
#include "parseabc.h"
#include "parser2.h"
#include "structs.h"
#include "drawtune.h"
extern void setscaling(char *s);
extern void font_command();
extern void setup_fonts();
extern void printtune(struct tune *t);
extern void set_keysig(struct key *k, struct key *newval);
/* forward definition */
void event_clef(char* clefstr, cleftype_t * new_clef);
programname fileprogram = YAPS;
extern int oldchordconvention; /* for handling +..+ chords */
struct voice* cv;
struct tune thetune;
char outputname[MAX_OUTPUTNAME + 1]; /* [JA] 2020-11-01 */
char outputroot[MAX_OUTPUTROOT + 1];
char matchstring[256];
int fileopen;
int xinhead;
int xinbody;
int suppress;
int debugging;
int pagenumbering;
int separate_voices;
int print_xref;
int landscape;
int barnums,nnbars;
extern int gchords_above;
extern int decorators_passback[DECSIZE]; /* a kludge for passing
information from the event_handle_instruction to parsenote
in parseabc.c */
enum linestattype {fresh, midmusic, endmusicline, postfield};
enum linestattype linestat;
int dummydecorator[DECSIZE]; /* used in event_chord */
void setfract(f, a, b)
struct fract* f;
int a, b;
/* assign value to fraction */
{
f->num = a;
f->denom = b;
}
void reducef(f)
struct fract* f;
/* reducef fraction to smallest terms */
{
int t, n, m;
/* find HCF using Euclid's algorithm */
if (f->num > f->denom) {
n = f->num;
m = f->denom;
} else {
n = f->denom;
m = f->num;
};
while (m != 0) {
t = n % m;
n = m;
m = t;
};
f->num = f->num/n;
f->denom = f->denom/n;
}
static struct fract* newfract(int a, int b)
/* create an initialized fraction */
{
struct fract* f;
f = (struct fract*)checkmalloc(sizeof(struct fract));
f->num = a;
f->denom = b;
return(f);
}
static timesig_details_t *newtimesig(void)
/* create an initialized time signature */
{
timesig_details_t *new_timesig;
new_timesig = (timesig_details_t *)checkmalloc (sizeof (timesig_details_t));
init_timesig(new_timesig);
return new_timesig;
}
static struct slurtie* newslurtie()
/* create a new slur/tie data structure */
{
struct slurtie* f;
f = (struct slurtie*)checkmalloc(sizeof(struct slurtie));
f->begin = NULL;
f->end = NULL;
f->crossline = 0;
return(f);
}
static struct atempo* newtempo(int count, int n, int m, int relative,
char *pre, char *post)
/* create an initialized tempo data structure */
{
struct atempo* t;
t = (struct atempo*)checkmalloc(sizeof(struct atempo));
t->count = count;
t->basenote.num = n;
t->basenote.denom = m;
t->relative = relative;
if (pre == NULL) {
t->pre = NULL;
} else {
t->pre = addstring(pre);
};
if (post == NULL) {
t->post = NULL;
} else {
t->post = addstring(post);
};
return(t);
}
static struct vertspacing* newvertspacing()
/* create new vertspacing structure */
{
struct vertspacing* p;
p = (struct vertspacing*)checkmalloc(sizeof(struct vertspacing));
p->height = 0.0;
p->descender = 0.0;
p->yend = 0.0;
p->yinstruct = 0.0;
p->ygchord = 0.0;
p->ywords = 0.0;
return(p);
}
static struct tuple* newtuple(int n, int q, int r, int label)
/* create tuple data structure */
{
struct tuple* f;
f = (struct tuple*)checkmalloc(sizeof(struct tuple));
f->n = n;
f->q = q;
f->r = r;
f->label = label;
f->beamed = 1;
return(f);
}
static struct chord* newchord()
/* create chord data structure */
{
struct chord* f;
f = (struct chord*)checkmalloc(sizeof(struct chord));
f->ytop = 0;
f->ybot = 0;
return(f);
}
cleftype_t *newclef (cleftype_t * source_clef)
/* create and initialize clef data structure */
{
cleftype_t *f; /* [JA] 2020-10-19 */
f = (cleftype_t *) checkmalloc (sizeof (cleftype_t));
copy_clef (f, source_clef);
return (f);
}
struct key* newkey(char* name, int sharps, char accidental[], int mult[])
/* create and initialize key signature */
{
struct key* k;
int i;
k = (struct key*)checkmalloc(sizeof(struct key));
k->name = addstring(name);
k->sharps = sharps;
for (i=0; i<7; i++) {
k->map[i] = accidental[i];
k->mult[i] = mult[i];
};
return(k);
}
void init_llist(struct llist* l)
/* initialize a linked list */
{
l->first = NULL;
l->last = NULL;
l->place = NULL;
}
void addtolist(struct llist* p, void* item)
/* append an item to a linked list */
{
struct el* x;
x = (struct el*)checkmalloc(sizeof(struct el));
x->next = NULL;
x->datum = item;
if (p->first == NULL) {
p->first = x;
p->last = x;
} else {
p->last->next = x;
p->last = x;
};
}
void* firstitem(struct llist* p)
/* find the first item in the list */
/* also initialize for a traversal using nextitem() */
{
if (p == NULL) {
return(NULL);
};
p->place = p->first;
if (p->place == NULL) {
return(NULL);
} else {
return(p->place->datum);
};
}
void* nextitem(struct llist* p)
/* return 'next' item in the list. Successive calls return successive */
/* items or NULL after the end of the list has been reached. firstitem() */
/* must be called prior to the first call to nextitem() */
{
if (p->place == NULL) {
return(NULL);
} else {
p->place = p->place->next;
if (p->place == NULL) {
return(NULL);
} else {
return(p->place->datum);
};
};
}
void freellist(struct llist* l)
/* frees up all dynamically allocated memory used to build the linked list */
{
void* p;
struct el* e;
struct el* olde;
/* printf("freellist\n"); */
if (l != NULL) {
p = firstitem(l);
while (p != NULL) {
free(p);
p = nextitem(l);
};
e = l->first;
while (e != NULL) {
olde = e;
e = e->next;
free(olde);
};
init_llist(l);
};
}
static void closebeam(struct voice* v)
/* called after a run of notes to be beamed together */
{
struct note* n;
struct feature* ft;
int stemup;
int ingrace;
if (cv->tuplenotes > 0) {
cv->thistuple->beamed = 0;
};
if (v->beamroot == v->beamend) {
ft = v->beamroot;
n = ft->item.voidptr;
n->beaming = single;
v->beamroot = NULL;
return;
};
if (v->beammax + v->beammin > 2*4) {
stemup = 0;
} else {
stemup = 1;
};
ft = v->beamroot;
ingrace = 0;
while ((ft != NULL) && (ft != v->beamend)) {
switch (ft->type) {
case NOTE:
if (ingrace == 0) {
n = ft->item.voidptr;
n->stemup = stemup;
};
break;
case GRACEON:
ingrace = 1;
break;
case GRACEOFF:
ingrace = 0;
break;
default:
break;
};
ft = ft->next;
};
if (ft == v->beamend) {
n = ft->item.voidptr;
n->stemup = stemup;
n->beaming = endbeam;
} else {
printf("closebeam: internal data error\n");
exit(1);
};
v->beamroot = NULL;
}
static void closegracebeam(struct voice* v)
/* called after a run of grace notes to be beamed together */
{
struct note* n;
struct feature* ft;
ft = v->gracebeamend;
if (ft == NULL) {
event_error("Missing grace notes");
} else {
n = ft->item.voidptr;
if (v->gracebeamroot == v->gracebeamend) {
n->beaming = single;
} else {
n->beaming = endbeam;
};
};
}
static void insertnote(struct feature* chordplace, struct feature* newfeature)
/* place NOTE in decreasing pitch order within chord */
{
struct note* n;
struct note* newnote;
struct feature* f;
struct feature* previous;
int foundplace;
newnote = newfeature->item.voidptr;
previous = chordplace;
f = chordplace->next;
foundplace = 0;
n = NULL;
while ((f != NULL)&&(f->type==NOTE)&&(foundplace == 0)) {
n = f->item.voidptr;
if (newnote->y > n->y) {
foundplace = 1;
} else {
previous = f;
f = f->next;
};
};
/* printvoiceline in drawtune.c expects the gchord or
* instructions to be associated with the first note in
* chord. If the notes are reordered then we need
* to move these fields.
* if previous == chordplace then move n->gchords and
* n->instructions to newnote->gchords and newnote->instructions
*/
if (previous == chordplace && n != NULL) {
newnote->gchords = n->gchords;
newnote->instructions = n->instructions;
n->gchords = NULL;
n->instructions = NULL;
}
newfeature->next = previous->next;
previous->next = newfeature;
if (newfeature->next == NULL) {
cv->last = newfeature;
};
}
static void beamitem(featuretype mytype, void* newitem, struct feature* x)
/* This routine is responsible for working out which notes are to be */
/* beamed together and recording this in the note structure record */
{
struct note* n;
/* deal with beaming here */
if (cv->ingrace) {
if ((mytype == NOTE) && (newitem != NULL)) {
n = newitem;
n->stemup = 1;
if (cv->gracebeamroot == NULL) {
cv->gracebeamroot = x;
cv->gracebeamend = x;
n->beaming = startbeam;
} else {
cv->gracebeamend = x;
n->beaming = midbeam;
};
};
} else {
if (cv->beamroot != NULL) {
switch (mytype) {
case NOTE:
n = newitem;
if (n->base_exp >= -2) {
n->beaming = single;
closebeam(cv);
} else {
/* extend beam */
if (n->y > cv->beammax) {
cv->beammax = n->y;
};
if (n->y < cv->beammin) {
cv->beammin = n->y;
};
cv->beamend = x;
n->beaming = midbeam;
};
break;
case KEY:
case REST:
case NOBEAM:
case SINGLE_BAR:
case DOUBLE_BAR:
case BAR_REP:
case REP_BAR:
case BAR1:
case REP_BAR2:
case DOUBLE_REP:
case THICK_THIN:
case THIN_THICK:
case TUPLE:
case MUSICSTOP:
/* closebeam */
closebeam(cv);
break;
default:
break;
};
} else {
if (mytype == NOTE) {
n = newitem;
if (n->base_exp >= -2) {
n->beaming = single;
} else {
n->beaming = startbeam;
cv->beammax = n->y;
cv->beammin = n->y;
cv->beamroot = x;
cv->beamend = x;
};
};
};
};
}
/* initialize a feature struct with empty values */
static void init_feature (struct feature *x, featuretype mytype)
{
x->next = NULL;
x->type = mytype;
x->item.voidptr = NULL;
x->xleft = 0;
x->xright = 0;
x->yup = 0;
x->ydown = 0;
}
static struct feature *addnumberfeature (featuretype mytype, int number)
/* handles numeric feature types
* may mark the end of a beamed section, so still need to call
* beamitem() on these
*/
{
struct feature *x;
if (cv == NULL) {
printf ("ERROR: no current voice in addfeature(status,type=%d\n", mytype);
//printf("status->inhead = %d status->inbody = %d\n", status->inhead, status->inbody);
exit (0);
}
x = (struct feature *)checkmalloc (sizeof (struct feature));
init_feature (x, mytype);
x->item.number = number;
if (cv->first == NULL) {
cv->first = x;
cv->last = x;
beamitem (mytype, NULL, x);
} else {
if ((cv->last == NULL) || (cv->last->next != NULL)) {
printf ("expecting NULL at list end!\n");
exit (0);
}
cv->last->next = x;
cv->last = x;
beamitem (mytype, NULL, x);
}
return (x);
}
static struct feature* addfeature(featuretype mytype, void* newitem)
/* append a new data element to the linked list for the current voice */
/* The element can be a note or lots of other things */
{
struct voice* p;
struct feature* x;
p = cv;
/* printf("in addfeature type=%d\n", mytype); */
if (cv == NULL) {
printf("ERROR: no current voice in addfeature type=%d\n", mytype);
printf("xinhead = %d xinbody = %d\n", xinhead, xinbody);
exit(0);
};
x = (struct feature*)checkmalloc(sizeof(struct feature));
init_feature (x, mytype);
x->item.voidptr = newitem;
if (cv->first == NULL) {
cv->first = x;
cv->last = x;
beamitem(mytype, newitem, x);
} else {
if ((cv->last == NULL)||(cv->last->next != NULL)) {
printf("expecting NULL at list end!\n");
exit(0);
};
if ((cv->inchord)&&(mytype==NOTE)) {
insertnote(cv->chordplace, x);
} else {
cv->last->next = x;
cv->last = x;
beamitem(mytype, newitem, x);
};
};
return(x);
}
struct llist* newlist()
/* create and initialize a new linked list */
{
struct llist* l;
l = (struct llist*)checkmalloc(sizeof(struct llist));
init_llist(l);
return(l);
}
static int notenum(int octave, char ch, cleftype_t * clef)
/* converts note to number for stave position */
/* note E is zero (bottom line of stave) */
{
int n;
n = 1 + (7 + ch - 'c') % 7 + 7 * (octave - 1);
/* apply shift associated with type of clef */
switch (clef->basic_clef) {
default:
case basic_clef_treble:
case basic_clef_auto:
case basic_clef_perc:
case basic_clef_none:
case basic_clef_undefined:
/* no shift */
break;
case basic_clef_bass:
n = n + 8;
break;
case basic_clef_alto:
n = n + 4;
break;
}
/* apply any shift from the placing of the clef */
n = n + (2 * clef->staveline);
/* We ignore octave shift from the clef. This is understood as an
* instruction to the player to play in a different octave, but
* the written notes do not change position.
*/
return (n);
}
int count_dots(int *base, int *base_exp, int n, int m)
/* convert fraction to 2^base_exp followed by dots */
/* previously used 1/base instead of 2^base_exp */
/* -1 indicates a note value which is impossible to represent */
{
int dots;
int start;
int a, b;
*base = 1; /* set default value if we fail */
*base_exp = 0;
if ((n<1)||(m<1)) {
return(-1);
};
/* check denominator is power of 2 */
a = m;
while (a>1) {
if (a%2 == 1) {
return(-1);
};
a = a/2;
};
dots = 0;
start = m;
while (start < n) {
start = start*2;
*base_exp = *base_exp + 1;
};
while (start > n) {
start = start/2;
*base_exp = *base_exp - 1;
};
if (start == 0) {
printf("Problem with %d / %d\n", n, m);
exit(0);
};
*base = m/start;
a = n - start;
b = start;
while (a>0) {
dots = dots + 1;
b = b/2;
a = a - b;
if (a< 0) {
return(-1);
};
};
return(dots);
}
static char* decstring(int decorators[])
/* creates a string of decorators (ornament, staccato, roll, up-bow etc.) */
/* from a boolean array */
{
int i, j;
char decs[DECSIZE+1];
j = 0;
for (i=0; i<DECSIZE; i++) {
if (decorators[i]) {
decs[j] = decorations[i];
j = j + 1;
};
};
decs[j] = '\0';
if (j==0) {
return(NULL);
} else {
return(addstring(decs));
};
}
static struct note* newnote(decorators, clef, xaccidental, xmult, xnote, xoctave,
a, b)
int decorators[DECSIZE];
cleftype_t *clef; /* [JA] 2020-10-19 */
int xmult;
char xaccidental, xnote;
int xoctave;
int a, b;
/* create and set up the fields for a note structure */
{
struct note* n;
n = (struct note*)checkmalloc(sizeof(struct note));
setfract(&n->len, a, b);
reducef(&n->len);
n->dots = count_dots(&n->base, &n->base_exp, n->len.num, n->len.denom);
/*
if (n->dots == -1) {
event_error("Illegal note length");
};
*/
n->accents = decstring(decorators);
n->accidental = xaccidental;
n->acc_offset = 0;
n->fliphead = 0;
n->mult = xmult;
n->octave = xoctave;
n->pitch = xnote;
n->y = notenum(xoctave, xnote, clef);
if (n->y < 4) {
n->stemup = 1;
} else {
n->stemup = 0;
};
n->beaming = single; /* initial default value */
n->syllables = NULL;
if (cv->ingrace) {
n->gchords = NULL;
n->instructions = NULL;
} else {
n->gchords = cv->gchords_pending;
cv->gchords_pending = NULL;
n->instructions = cv->instructions_pending;
cv->instructions_pending = NULL;
};
n->stemlength = 0.0;
return(n);
}
static struct rest* newrest(int a, int b, int multi)
/* create and set up a new rest structure */
{
struct rest* n;
n = (struct rest*)checkmalloc(sizeof(struct rest));
setfract(&n->len, a, b);
n->dots = count_dots(&n->base, &n->base_exp, a, b);
if (n->dots == -1) {
event_error("Illegal rest length");
};
n->multibar = multi;
if (cv->ingrace) {
n->gchords = NULL;
n->instructions = NULL;
} else {
n->gchords = cv->gchords_pending;
cv->gchords_pending = NULL;
n->instructions = cv->instructions_pending;
cv->instructions_pending = NULL;
};
return(n);
}
static void addunits(f, n, m)
struct fract* f;
int n, m;
/* add n/m to fraction pointed to by f */
{
f->num = n*f->denom*(cv->unitlen.num) + f->num*(m*cv->unitlen.denom);
f->denom = (m*cv->unitlen.denom)*f->denom;
reducef(f);
}
static void addfractions(f,n,m)
struct fract* f;
int n,m;
{
f->num = n*f->denom + f->num*m;
f->denom = m*f->denom;
reducef(f);
}
static struct voice* newvoice(int n)
/* create and set up a new voice data structure */
{
struct voice* v;
v = (struct voice*)checkmalloc(sizeof(struct voice));
v->first = NULL;
v->last = NULL;
v->voiceno = n;
v->octaveshift = thetune.octaveshift;
setfract(&v->unitlen, thetune.unitlen.num, thetune.unitlen.denom);
v->changetime = 0;
v->inslur = 0;
v->ingrace = 0;
v->inchord = 0;
v->tuplenotes = 0;
v->thistuple = NULL;
v->tuple_count = 0;
v->brokenpending = -1;
v->tiespending = 0;
v->slurpending = 0;
v->slurcount = 0;
v->barno = 0;
v->barchecking = thetune.barchecking;
setfract (&v->barlen, thetune.timesig.num, thetune.timesig.denom);
v->clef = newclef(&thetune.clef);
if (thetune.keysig == NULL) {
printf("Trying to set up voice with no key signature\n");
exit(0);
} else {
v->keysig = newkey(thetune.keysig->name, thetune.keysig->sharps,
thetune.keysig->map, thetune.keysig->mult);
};
v->tempo = NULL;
setfract(&v->barcount, 0, 1);
copy_timesig(&v->timesig, &thetune.timesig);
v->lastnote = NULL;
v->laststart = NULL;
v->lastend = NULL;
v->line = header;
v->thisstart = NULL;
v->thisend = NULL;
v->gchords_pending = NULL;
v->instructions_pending = NULL;
v->beamed_tuple_pending = 0;
v->linestart = NULL;
v->lineend = NULL;
v->more_lyrics = 0;
v->lyric_errors = 0;
v->thischord = NULL;
v->chordplace = NULL;
v->beamroot = NULL;
v->beamend = NULL;
v->gracebeamroot = NULL;
v->gracebeamend = NULL;
return(v);
}
static void setvoice(int n)
/* set current voice to voice n. If voice n does not exist, create it */
{
struct voice* v;
struct el* l;
int done;
if (thetune.voices.first == NULL) {
cv = newvoice(n);
v = cv;
addtolist(&thetune.voices, (void*)v);
} else {
l = thetune.voices.first;
done = 0;
while ((done == 0) && (l != NULL)) {
if (((struct voice*)l->datum)->voiceno == n) {
done = 1;
cv = (struct voice*)l->datum;
} else {
l = l->next;
};
};
if (done == 0) {
cv = newvoice(n);
v = cv;
addtolist(&thetune.voices, (void*)v);
};
};
}
static void init_tune(struct tune* t, int x)
/* initialize tune structure */
{
t->no = x;
t->octaveshift = 0;
init_llist(&t->title);
t->composer = NULL;
t->origin = NULL;
t->parts = NULL;
init_llist(&t->notes);
init_llist(&t->voices);
init_timesig(&t->timesig);
setfract(&t->unitlen, 0, 1);
t->cv = NULL;
t->keysig = NULL;
init_new_clef (&t->clef);
get_standard_clef ("treble", &t->clef); /* default to treble clef */
t->tempo = NULL;
init_llist(&t->words);
};
static void freekey(struct key* k)
/* free up memory allocated for key data structure */
{
if (k != NULL) {
if (k->name != NULL) {
free(k->name);
};
free(k);
};
}
static void freetempo(struct atempo *t)
/* free up memory allocated for temp data structure */
{
if (t->pre != NULL) {
free(t->pre);
};
if (t->post != NULL) {
free(t->post);
};
}
static void freefeature(void* item, featuretype type)
/* free memory allocated for feature in voice */
{
struct note *n;
struct rest *r;
switch(type) {
case NOTE:
case CHORDNOTE:
n = item;
if (n->accents != NULL) {
free(n->accents);
};
if (n->syllables != NULL) {
freellist(n->syllables);
free(n->syllables);
};
if (n->gchords != NULL) {
freellist(n->gchords);
free(n->gchords);
};
if (n->instructions != NULL) {
freellist(n->instructions);
free(n->instructions);
};
free(n);
break;
case REST:
r = item;
if (r->gchords != NULL) {
freellist(r->gchords);
free(r->gchords);
};
if (r->instructions != NULL) {
freellist(r->instructions);
free(r->instructions);
};
free(r);
break;
case KEY:
freekey(item);
break;
case TEMPO:
freetempo(item);
break;
case CLEF:
case TIME:
case PART:
case CHORDON:
case TUPLE:
case SLUR_ON:
case TIE:
case PLAY_ON_REP:
case LEFT_TEXT:
case PRINTLINE:
if (item != NULL) {
free(item);
};
break;
default:
break;
};
}
static void freevoice(struct voice* v)
/* free up memory allocated for voice data structure and voice data */
{
struct feature* ft;
struct feature* oldft;
ft = v->first;
while (ft != NULL) {
freefeature(ft->item.voidptr, ft->type);
oldft = ft;
ft = ft->next;
free(oldft);
};
if (v->keysig != NULL) {
freekey(v->keysig);
v->keysig = NULL;
};
if (v->tempo != NULL) {
freetempo(v->tempo);
free (v->tempo);
v->tempo = NULL;
};
if (v->clef != NULL) {
free(v->clef);
};
v->clef = NULL;
}
static void freetune(struct tune* t)
/* free up all dynamically allocated memory associated with tune */
{
struct voice* v;
if (t->composer != NULL) {
free(t->composer);
t->composer = NULL;
};
if (t->origin != NULL) {
free(t->origin);
t->origin = NULL;
};
if (t->parts != NULL) {
free(t->parts);
t->parts = NULL;
};
freellist(&t->title);
freellist(&t->notes);
if (t->keysig != NULL) {
freekey(t->keysig);
t->keysig = NULL;
};
if (t->tempo != NULL) {
freetempo(t->tempo);
free(t->tempo);
t->tempo = NULL;
};
v = firstitem(&t->voices);
while (v != NULL) {
freevoice(v);
v = nextitem(&t->voices);
};
freellist(&t->voices);
freellist(&t->words);
}
static int checkmatch(int refno)
/* compares current reference number against list of numbers */
/* following -e argument */
/* returns 1 if tune has been selected and 0 otherwise */
{
int select;
int n1, n2;
char* place;
place = matchstring;
if (strlen(matchstring)==0) {
select = 1;
} else {
select = 0;
while ((select==0)&&(*place >= '0')&&(*place <='9')) {
n1 = readnump(&place);
if (n1 == refno) {
select = 1;
} else {
if (*place == ',') {
place = place+1;
} else {
if (*place == '-') {
place = place+1;
n2 = readnump(&place);
if ((refno >= n1)&&(refno <= n2)) {
select = 1;
} else {
if (*place == ',') {
place = place+1;
};
};
};
};
};
};
if ((select==0)&&(*place != '\0')) {
event_warning("Number list after -e not fully parsed");
};
};
return(select);
}
void event_init(argc, argv, filename)
int argc;
char* argv[];
char** filename;
/* initialization routine - called once at the start of the program */
/* interprets the parameters in argv */
{
char* place;
int filearg;
int refmatch;
int papsize, margins, newscale;
int ier;
int j;
if (getarg("-ver",argc, argv) != -1) {
printf("%s\n",VERSION);
exit(0);
}
if (getarg("-d", argc, argv) != -1) {
debugging = 1;
} else {
debugging = 0;
};
if (getarg("-E", argc, argv) != -1) {
eps_out = 1;
} else {
eps_out = 0;
};
if (getarg("-OCC",argc,argv) != -1) oldchordconvention=1;
if (getarg("-V", argc, argv) != -1) {
separate_voices = 1;
} else {
separate_voices = 0;
};
if (getarg("-x", argc, argv) != -1) {
print_xref = 1;
} else {
print_xref = 0;
};
if (getarg("-N", argc, argv) != -1) {
pagenumbering = 1;
} else {
pagenumbering = 0;
};
if (getarg("-l", argc, argv) != -1) {
landscape = 1;
} else {
landscape = 0;
};
newscale = getarg("-s", argc, argv);
if ((newscale != -1) && (argc >= newscale+1)) { /* [SS] 2015-02-22 */
setscaling(argv[newscale]);
} else {
setscaling("");
};
margins = getarg("-M", argc, argv);
if ((margins != -1) && (argc >= margins)) {
setmargins(argv[margins]);
} else {
setmargins("");
};
papsize = getarg("-P", argc, argv);
if ((papsize != -1) && (argc >= papsize)) {
setpagesize(argv[papsize]);
} else {
setpagesize("");
};
barnums = getarg("-k",argc,argv);
ier = 0;
if ((barnums != -1) && (argc > barnums)) ier = sscanf(argv[barnums],"%d",&nnbars);
if ((barnums != -1) && (ier <1)) nnbars = 1;
refmatch = getarg("-e", argc, argv);
if (refmatch == -1) {
*matchstring = '\0';
} else {
if (strlen(argv[refmatch]) < 255) {
strcpy(matchstring, argv[refmatch]);
} else {
event_error("Exceeded character limit for -e string");
exit(1);
};
};
if ((getarg("-h", argc, argv) != -1) || (argc < 2)) {
printf("yaps version %s\n",VERSION);
printf("Usage: yaps <abc file> [<options>]\n");
printf(" possible options are -\n");
printf(" -ver :prints version number and exits\n");
printf(" -d : debug - display data structure\n");
printf(" -e <list> : draw tunes with reference numbers in list\n");
printf(" list is comma-separated and may contain ranges\n");
printf(" but no spaces e.g. 1,3,7-20\n");
printf(" -E : generate Encapsulated PostScript\n");
printf(" -l : landscape mode\n");
printf(" -M XXXxYYY : set margin sizes in points\n");
printf(" 28.3 points = 1cm, 72 points = 1 inch\n");
printf(" -N : add page numbering\n");
printf(" -k [nn] : number every nn bars\n");
printf(" -o <filename> : specify output file\n");
printf(" -P ss : paper size; 0 is A4, 1 is US Letter\n");
printf(" or XXXxYYY to set size in points\n");
printf(" -s XX : scaling factor (default is 0.7)\n");
printf(" -V : separate voices in multi-voice tune\n");
printf(" -x : print tune number in X: field\n");
printf(" -OCC : old chord convention (eg. +CE+)\n");
printf("Takes an abc music file and converts it to PostScript.\n");
printf("If no output filename is given, then by default it is\n");
printf("the input filename but with extension .ps .\n");
exit(0);
} else {
*filename = argv[1];
};
fileopen = 0;
filearg = getarg("-o", argc, argv);
/* beware of security risk from buffer overflows here [JA] 2020-11-01*/
if (filearg != -1) {
if (strlen(argv[filearg]) > MAX_OUTPUTROOT) /* [JA] 2020-11-01 */
{
printf("Specified output filename exceeds limit.\n");
exit(1);
}
#ifdef NO_SNPRINTF
sprintf(outputname, "%s",argv[filearg]); /* [SS] 2020-11-01 */
#else
snprintf(outputname, MAX_OUTPUTROOT,"%s",argv[filearg]);
#endif
} else {
if (strlen(argv[1]) > MAX_OUTPUTROOT)
{
printf("Implied output filename exceeds limit.\n");
exit(1);
}
#ifdef NO_SNPRINTF
sprintf(outputname,"%s", argv[1]); /* [SS] 2020-11-01 */
#else
snprintf(outputname,MAX_OUTPUTROOT,"%s", argv[1]);
#endif
place = strchr(outputname, '.');
if (place == NULL) {
strcat(outputname, ".ps");
} else {
strcpy(place, ".ps");
};
if (strcmp(argv[1], outputname)==0) {
printf("argument must be abc file, not PostScript file\n");
exit(1);
};
};
/* create filename root for EPS output */
strcpy(outputroot, outputname);
place = strchr(outputroot, '.');
if (place != NULL) {
*place = '\0';
};
xinbody =0;
xinhead = 0;
suppress = 0;
init_tune(&thetune, -1);
setup_fonts();
/* open_output_file(outputname); */
for (j=0;j<DECSIZE;j++) dummydecorator[j] = 0;
}
static void check_voice_end(struct voice* v)
/* make sure there are no unfinished structures */
{
if (v->inchord) {
event_error("incomplete chord at end of voice");
v->inchord = 0;
};
if (v->brokenpending != -1) {
event_error("incomplete broken rhythm at end of voice");
v->brokenpending = -1;
};
if ((v->slurcount > 0)||(v->slurpending)) {
event_error("incomplete slur at end of voice");
v->slurcount = 0;
v->slurpending = 0;
};
if (v->tiespending) {
event_error("incomplete ties at end of voice");
v->tiespending = 0;
};
if (v->gchords_pending != NULL) {
freellist(v->gchords_pending);
free(v->gchords_pending);
v->gchords_pending = NULL;
};
if (v->instructions_pending != NULL) {
freellist(v->instructions_pending);
free(v->instructions_pending);
v->instructions_pending = NULL;
};
if (v->tuplenotes > 0) {
event_error("incomplete tuple at end of voice");
v->tuplenotes = 0;
};
}
static void check_tune_end(struct tune* t)
/* check that all voices have been completed properly */
{
struct voice* v;
v = firstitem(&t->voices);
while (v != NULL) {
check_voice_end(v);
v = nextitem(&t->voices);
};
}
void event_eof()
/* end of input file has been encountered */
{
if (xinbody) {
check_tune_end(&thetune);
printtune(&thetune);
};
freetune(&thetune);
close_output_file();
}
void event_blankline()
/* A blank line has been encountered */
{
if (xinbody) {
check_tune_end(&thetune);
printtune(&thetune);
};
freetune(&thetune);
xinbody = 0;
xinhead = 0;
suppress = 0;
parseroff();
}
void event_text(p)
/* Text outside an abc tune has been encountered */
char *p;
{
}
void event_x_reserved(p)
char p;
{
}
void event_abbreviation(symbol, string, container)
/* abbreviation declaratiion - handled by parser. Ignore it here */
char symbol;
char *string;
char container;
{
}
void event_acciaccatura()
{
/* does nothing but outputs a / in toabc.c */
return;
}
/* [SS] 2015-03-23 */
void event_start_extended_overlay()
{
event_error("extended overlay not implemented in yaps");
}
void event_stop_extended_overlay()
{
event_error("extended overlay not implemented in yaps");
}
void event_split_voice()
{
addnumberfeature(SPLITVOICE, lineno);
event_error("voice split not implemented in yaps");
}
void event_tex(s)
char *s;
/* A TeX command has been found in the abc */
{
}
void event_linebreak()
/* A linebreak has been encountered */
{
/* [SS] 2015-11-15 * changed (void*) to (int *) */
if (xinbody) {
addnumberfeature(LINENUM, lineno);
};
}
static void tidy_ties()
/* create CLOSE_TIE features for ties straddling two lines of music */
/* CLOSE_TIE appears in the new music line */
{
struct feature* ft;
struct slurtie* s;
int i;
for (i=0; i<cv->tiespending; i++) {
ft = cv->tie_place[i]; /* pointer to TIE feature */
s = ft->item.voidptr;
addfeature(CLOSE_TIE, s);
};
}
void event_startmusicline()
/* We are at the start of a line of abc notes */
{
voice_context_t *parser_voice;
parser_voice = &voicecode[voicenum - 1];
cv->linestart = addnumberfeature(MUSICLINE, 0);
if (cv->more_lyrics != 0) {
event_error("Missing continuation w: field");
cv->more_lyrics = 0;
};
if ((cv->line == header) || (cv->line == newline)) {
addfeature(CLEF, newclef(cv->clef));
addfeature(KEY, newkey(cv->keysig->name, cv->keysig->sharps,
cv->keysig->map, cv->keysig->mult));
if ((cv->line == header)||(cv->changetime)) {
timesig_details_t *timesig;
timesig = newtimesig();
copy_timesig(timesig, &parser_voice->timesig);
addfeature (TIME, timesig);
cv->changetime = 0;
};
cv->line = midline;
tidy_ties();
};
cv->lineend = NULL;
}
static void divide_ties()
/* mark unresolved ties and slurs as straddling two lines of music */
{
struct feature* ft;
struct slurtie* s;
int i;
for (i=0; i<cv->tiespending; i++) {
ft = cv->tie_place[i]; /* pointer to TIE feature */
s = ft->item.voidptr;
s->crossline = 1;
};
for (i=0; i<cv->slurcount; i++) {
s = cv->slur_place[i];
s->crossline = 1;
};
}
/* A score_linebreak has been encountered [JA] 2020-10-07*/
void event_score_linebreak (char ch)
{
if (xinbody) {
/* end current score line - code from endmusicline */
cv->lineend = addnumberfeature (MUSICSTOP, 0);
addfeature (PRINTLINE, newvertspacing ());
cv->line = newline;
divide_ties ();
/* start new score line - startmusicline */
event_startmusicline ();
}
}
void event_endmusicline(endchar)
char endchar;
/* We are at the end of a line of abc notes */
{
cv->lineend = addnumberfeature(MUSICSTOP, 0);
if ((endchar == ' ') || (endchar == '!')) {
addfeature(PRINTLINE, newvertspacing());
cv->line = newline;
divide_ties();
};
}
void event_error(s)
char *s;
/* report any error message */
{
printf("Error in line %d : %s\n", lineno, s);
}
void event_warning(s)
char *s;
/* report any warning message */
{
printf("Warning in line %d : %s\n", lineno, s);
}
void event_comment(s)
char *s;
/* A comment has been encountered in the input */
{
}
int make_open()
/* called as fileopen = make_open() */
/* if file is not already open, open it and set fileopen */
{
if (fileopen == 0) {
open_output_file(outputname, (void*)NULL);
fileopen = 1;
};
return(1);
}
void event_specific(p, str)
char *p; /* first word after %% */
char *str; /* string following first word */
/* The special comment %% has been found */
/* abc2midi uses it for the %%MIDI commands */
/* yaps implements some of the abc2ps commands */
{
char* s;
double vspace;
char units[80];
int count;
/* ensure file has been opened since most commands require this */
if (!eps_out) {
fileopen = make_open();
};
s = str;
skipspace(&s);
if (strcmp(p, "newpage") == 0) {
if (xinbody == 0) {
if (fileopen) {
newpage();
};
} else {
addfeature(NEWPAGE, (void*)NULL);
};
};
if (strcmp(p, "text") == 0) {
if (xinbody == 0) {
if (fileopen) {
lefttext(s);
};
} else {
addfeature(LEFT_TEXT, addstring(s));
};
};
if ((strcmp(p, "centre") == 0) || (strcmp(p, "center") == 0)) {
if (xinbody == 0) {
if (fileopen) {
centretext(s);
};
} else {
addfeature(CENTRE_TEXT, addstring(s));
};
};
if (strcmp(p, "vskip") == 0) {
count = sscanf(s, "%lf%s", &vspace, units);
if (count > 0) {
if ((count >= 2) && (strncmp(units, "cm", 2) == 0)) {
vspace = vspace*28.3;
};
if ((count >= 2) && (strncmp(units, "in", 2) == 0)) {
vspace = vspace*72.0 ;
};
if (xinbody == 0) {
if (fileopen) {
vskip(vspace);
};
} else {
addnumberfeature(VSKIP, (int)vspace);
};
};
};
if (strcmp(p, "chordsabove") == 0) {
gchords_above = 1;
};
if (strcmp(p, "chordsbelow") == 0) {
gchords_above = 0;
};
/* look for font-related commands */
font_command(p, s);
}
void event_field(k, f)
char k;
char *f;
/* A field line has been encountered in the input abc */
{
switch (k) {
case 'T':
if (debugging) {
printf("T:%s\n", f);
};
addtolist(&thetune.title, addstring(f));
break;
case 'C':
if (thetune.composer != NULL) {
event_error("More than one C: field in tune");
} else {
thetune.composer = addstring(f);
};
break;
case 'O':
if (thetune.origin != NULL) {
event_error("More than one O: field in tune");
} else {
thetune.origin = addstring(f);
};
break;
case 'W':
if (debugging) {
printf("W:%s\n", f);
};
addtolist(&thetune.words, addstring(f));
break;
case 'N':
addtolist(&thetune.notes, addstring(f));
break;
default:
break;
};
}
struct feature* findbar(struct feature* wordplace, int* errors)
/* hunts through voice to find next bar data structure */
{
struct feature* ft;
ft = wordplace;
while ((ft != NULL) && (ft != cv->lineend) && (ft->type != MUSICSTOP) &&
(ft->type != SINGLE_BAR) && (ft->type != DOUBLE_BAR) &&
(ft->type != BAR_REP) && (ft->type != REP_BAR) &&
(ft->type != DOUBLE_REP) && (ft->type != THICK_THIN) &&
(ft->type != THIN_THICK) && (ft->type != BAR1) &&
(ft->type != REP_BAR2)) {
ft = ft->next;
};
if ((ft == NULL) || (ft == cv->lineend) || (ft->type == MUSICSTOP)) {
*errors = *errors + 1;
} else {
ft = ft->next;
};
return(ft);
}
struct feature* apply_syll(char* s, struct feature* wordplace, int* errors)
/* attaches a syllable from the lyrics to the appropriate note */
{
struct note* n;
struct feature* ft;
int inchord;
ft = wordplace;
inchord = 0;
while ((ft != NULL) && (ft != cv->lineend) &&
(ft->type != NOTE)) {
if (ft->type == CHORDON) {
inchord = 1;
};
ft = ft->next;
/* skip over any grace notes */
if ((ft != NULL) && (ft->type == GRACEON)) {
while ((ft != NULL) && (ft != cv->lineend) &&
(ft->type != GRACEOFF)) {
ft = ft->next;
};
};
};
if ((ft == NULL) || (ft == cv->lineend)) {
*errors = *errors + 1;
return(ft);
};
if (ft->type == NOTE) {
n = ft->item.voidptr;
if (n->syllables == NULL) {
n->syllables = newlist();
};
/*
if (strlen(s) < 80) {
ISOdecode(s, isocode);
addtolist(n->syllables, addstring(isocode));
} else {
*/
addtolist(n->syllables, addstring(s));
/*
};
*/
};
ft = ft->next;
/* skip over any chord */
if (inchord) {
while ((ft != NULL) && (ft->type != CHORDOFF) && (ft != cv->lineend)) {
ft = ft->next;
};
};
return(ft);
}
void event_words(p, continuation)
char* p;
int continuation;
/* A line of lyrics (w: ) has been encountered in the abc */
{
struct vstring syll;
char* q;
struct feature* wordplace;
unsigned char ch;
int errors;
if (!xinbody) {
if (!suppress) {
event_error("w: field outside tune body");
};
return;
};
wordplace = cv->linestart;
if (cv->more_lyrics) {
errors = cv->lyric_errors;
} else {
errors = 0;
};
if (wordplace == NULL) {
event_error("No notes to match words");
return;
};
initvstring(&syll);
q = p;
skipspace(&q);
while (*q != '\0') {
clearvstring(&syll);
ch = *q;
while(ch=='|') {
wordplace = findbar(wordplace, &errors);
q++;
ch = *q;
};
while (((ch>127)||isalnum(ch)||ispunct(ch))&&
(ch != '_')&&(ch != '-')&&(ch != '*')&& (ch != '|')) {
if (ch == '~') {
ch = ' ';
};
if ((ch == '\\') && (*(q+1)=='-')) {
ch = '-';
q++;
};
/* syllable[i] = ch; */
addch(ch, &syll);
q++;
ch = *q;
};
skipspace(&q);
if (ch == '-') {
addch(ch, &syll);
while (isspace(ch)||(ch=='-')) {
q++;
ch = *q;
};
};
if (syll.len > 0) {
wordplace = apply_syll(syll.st, wordplace, &errors);
} else {
if (ch=='_') {
clearvstring(&syll);
addch('_', &syll);
wordplace = apply_syll(syll.st, wordplace, &errors);
q++;
ch = *q;
};
if (ch=='*') {
clearvstring(&syll);
addch(' ', &syll);
wordplace = apply_syll(syll.st, wordplace, &errors);
q++;
ch = *q;
};
};
};
if (continuation) {
cv->more_lyrics = 1;
cv->lyric_errors = errors;
cv->linestart = wordplace;
} else {
cv->more_lyrics = 0;
if (errors > 0) {
event_error("Lyric line too long for music");
} else {
clearvstring(&syll);
wordplace = apply_syll(syll.st, wordplace, &errors);
if (errors == 0) {
event_error("Lyric line too short for music");
};
};
};
freevstring(&syll);
}
/* [SS] 2014-08-16 */
void appendfield (morewords)
char *morewords;
{
printf("appendfield not implemented here\n");
}
void event_part(s)
char* s;
/* A part field (P: ) has been encountered in the abc */
{
char label[200]; /* [SS] 2010-12-12 */
if (xinhead) {
if (thetune.parts != NULL) {
event_error("Multiple P: fields in header");
} else {
thetune.parts = addstring(s);
};
};
if (xinbody) {
/* addfeature(PART, addstring(s)); */
/* PART is handled like an instruction */
if (cv->instructions_pending == NULL) {
cv->instructions_pending = newlist();
};
sprintf(label, ":p%s", s);
addtolist(cv->instructions_pending, addstring(label));
};
}
void event_voice(n, s, vp)
int n;
char *s;
struct voice_params *vp;
/* A voice field (V: ) has been encountered */
{
if (xinbody) {
setvoice(n);
if (vp->gotclef) {
event_clef (vp->clefname, &vp->new_clef);
}
if (vp->gotoctave) {
event_octave (vp->octave, 0);
}
} else {
if (!suppress) {
event_error("V: field outside tune body");
};
};
}
void event_length(n)
int n;
/* A length field (L: ) has been encountered */
{
if (xinhead) {
setfract(&thetune.unitlen, 1, n);
} else {
if (xinbody) {
setfract(&cv->unitlen, 1, n);
} else {
if (!suppress) {
event_warning("L: field outside tune ignored");
};
};
};
}
void event_default_length (n)
int n;
/* Handles a missing L: field */
{
event_length(n);
}
void event_refno(n)
int n;
/* A reference field (X: ) has been encountered. This indicates the start */
/* of a new tune */
{
if (xinhead) {
event_error("incomplete tune");
};
if (xinbody) {
check_tune_end(&thetune);
printtune(&thetune);
};
freetune(&thetune);
xinbody = 0;
xinhead = 0;
suppress = 0;
parseroff();
if (debugging) {
printf("X:%d\n", n);
};
if (checkmatch(n)) {
parseron();
/* fileopen = make_open(); */
xinhead = 1;
xinbody = 0;
init_tune(&thetune, n);
} else {
suppress = 1;
};
}
void event_tempo(n, a, b, relative, pre, post)
int n, a, b;
int relative;
char *pre; /* text before tempo */
char *post; /* text after tempo */
/* A tempo field Q: has been encountered in the abc */
/* Q:a/b=N will have relative = 0 */
/* Q:N will have a=0 and b=0 */
/* Q:Ca/b = N will have relative = 1 */
{
if (xinhead) {
thetune.tempo = newtempo(n, a, b, relative, pre, post);
} else {
if (xinbody) {
if ((a == 0) && (b == 0)) {
addfeature(TEMPO, newtempo(n, cv->unitlen.num, cv->unitlen.denom, 0,
pre, post));
} else {
addfeature(TEMPO, newtempo(n, a, b, relative, pre, post));
};
} else {
if (!suppress) {
event_warning("Q: field outside tune ignored");
};
};
};
}
void event_timesig (timesig)
timesig_details_t *timesig;
/* A time signature (M: ) has been encountered in the abc */
{
int checkbars;
if (timesig->type == TIMESIG_FREE_METER) {
checkbars = 0;
} else {
checkbars = 1;
}
if (xinhead) {
copy_timesig(&thetune.timesig, timesig);
thetune.barchecking = checkbars;
} else {
if (xinbody) {
timesig_details_t *time_timesig;
time_timesig = newtimesig();
copy_timesig(time_timesig, timesig);
addfeature (TIME, time_timesig);
setfract (&cv->barlen, timesig->num, timesig->denom);
if (cv->line != midline) {
cv->changetime = 1;
}
} else {
if (!suppress) {
event_warning ("M: field outside tune ignored");
};
};
};
}
void event_clef(char* clefstr, cleftype_t * new_clef)
/* a clef has been encountered in the abc */
{
if (new_clef->basic_clef == basic_clef_undefined) {
return;
}
if (xinbody) {
copy_clef (cv->clef, new_clef);
addfeature (CLEF, newclef (new_clef));
};
if ((xinhead) && (!xinbody)) {
copy_clef (&thetune.clef, new_clef);
};
}
void setmap(sf, map, mult)
/* work out accidentals to be applied to each note */
int sf; /* number of sharps in key signature -7 to +7 */
char map[7];
int mult[7];
{
int j;
for (j=0; j<7; j++) {
map[j] = '=';
mult[j] = 1;
};
if (sf >= 1) map['f'-'a'] = '^';
if (sf >= 2) map['c'-'a'] = '^';
if (sf >= 3) map['g'-'a'] = '^';
if (sf >= 4) map['d'-'a'] = '^';
if (sf >= 5) map['a'-'a'] = '^';
if (sf >= 6) map['e'-'a'] = '^';
if (sf >= 7) map['b'-'a'] = '^';
if (sf <= -1) map['b'-'a'] = '_';
if (sf <= -2) map['e'-'a'] = '_';
if (sf <= -3) map['a'-'a'] = '_';
if (sf <= -4) map['d'-'a'] = '_';
if (sf <= -5) map['g'-'a'] = '_';
if (sf <= -6) map['c'-'a'] = '_';
if (sf <= -7) map['f'-'a'] = '_';
}
void altermap(basemap, basemul, modmap, modmul)
/* apply modifiers to a set of accidentals */
char basemap[7], modmap[7];
int basemul[7], modmul[7];
{
int i;
for (i=0; i<7; i++) {
if (modmap[i] != ' ') {
basemap[i] = modmap[i];
basemul[i] = modmul[i];
};
};
}
void resolve_tempo(struct atempo* t, struct fract* unitlen)
/* Tempo may be given relative to the unit note length. At the start of */
/* the tune, we will know what this is and can deduce the tempo value. */
/* Can also deduce tempo if it has been given as a number only. */
{
if (t->relative==1) {
setfract(&t->basenote, t->basenote.num*unitlen->num,
t->basenote.denom*unitlen->denom);
reducef(&t->basenote);
t->relative = 0;
};
if ((t->basenote.num == 0) && (t->basenote.denom == 0)) {
setfract(&t->basenote, unitlen->num, unitlen->denom);
reducef(&t->basenote);
};
}
static void start_body()
/* We have reached the end of the header section and need to set */
/* default values for anything not explicitly declared */
{
parseron();
/* missing M: is handled by setting default M:none */
/* missing L: is handled by event_default_length */
if (thetune.tempo != NULL) {
resolve_tempo(thetune.tempo, &thetune.unitlen);
};
}
void event_true_key(sharps, s, modeindex, modmap, modmul)
int sharps;
char *s;
int modeindex; /* 0 major, 1,2,3 minor, 4 locrian, etc. */
char modmap[7];
int modmul[7];
/* key detected in K: field */
{
char basemap[7];
int basemul[7];
struct key* akey;
int minor;
minor =0;
if (modeindex >0 && modeindex <4) minor = 1;
setmap(sharps, basemap, basemul);
altermap(basemap, basemul, modmap, modmul);
if (xinbody) {
akey = newkey(s, sharps, basemap, basemul);
addfeature(KEY, akey);
set_keysig(cv->keysig, akey);
};
if (xinhead) {
if (thetune.keysig == NULL) {
thetune.keysig = newkey(s, sharps, basemap, basemul);
} else {
event_warning("Key specified twice");
};
xinbody = 1;
xinhead = 0;
setvoice(1);
start_body();
};
}
void event_octave(int num, int local)
/* deals with the special command I:octave=N */
{
if (xinhead) {
thetune.octaveshift = num;
};
if (xinbody) {
cv->octaveshift = num;
};
}
void event_key(sharps, s, minor, modmap, modmul, modmicrotone, gotkey,
gotclef, clefstr, new_clef,
octave, transpose, gotoctave, gottranspose, explict)
int sharps;
char *s;
int minor;
char modmap[7];
int modmul[7];
struct fraction modmicrotone[7]; /* [SS] 2014-01-06 */
int gotkey, gotclef;
char* clefstr; /* [JA] 2020-10-19 */
cleftype_t * new_clef;
int octave, transpose, gotoctave, gottranspose;
int explict;
/* A key field (K: ) has been encountered */
{
if (xinhead || xinbody) {
if (gotclef==1) {
event_clef(clefstr, new_clef);
};
if (gotkey==1) {
event_true_key(sharps, s, minor, modmap, modmul);
};
};
if (gotclef)
{
event_octave(new_clef->octave_offset, 0);
}
if (gotoctave) {
event_octave(octave, 0);
};
}
static void checkbar(int type)
/* Make sure that bar lasts for the correct musical time */
{
int valid;
char msg[80];
int a1, a2;
valid = 0;
a1 = cv->barlen.num*cv->barcount.denom;
a2 = cv->barcount.num*cv->barlen.denom;
if (a1 == a2) {
cv->barcount.num = 0;
cv->barcount.denom = 1;
cv->barno = cv->barno + 1;
} else {
if (((type==BAR_REP)||(type==REP_BAR)||(type==DOUBLE_REP)) &&
(a1 > a2)) {
/* do nothing */
} else {
if ((cv->barno > 0) && (cv->barcount.num != 0) &&
(cv->barchecking != 0)) {
sprintf(msg, "Bar %d is %d/%d not %d/%d", cv->barno,
cv->barcount.num, cv->barcount.denom,
cv->barlen.num, cv->barlen.denom);
event_warning(msg);
cv->barcount.num = 0;
cv->barcount.denom = 1;
cv->barno = cv->barno + 1;
} else {
cv->barcount.num = 0;
cv->barcount.denom = 1;
cv->barno = cv->barno + 1;
};
};
};
}
void event_bar(type, playonrep_list)
int type;
char* playonrep_list;
/* A bar has been encountered in the abc */
{
if (cv->inchord) {
event_warning("Bar line not permitted within chord");
return;
};
checkbar(type); /* increment bar number if bar complete */
/* [SS] 2015-11-15 * changed (void*) to (int *) */
addnumberfeature(type, cv->barno); /* save bar number */
if ((playonrep_list != NULL) && (strlen(playonrep_list) > 0)) {
event_playonrep(playonrep_list);
};
}
void event_space()
/* A region of whitespace has been encountered */
{
addfeature(NOBEAM, NULL);
}
void event_graceon()
/* start of grace note(s) */
{
if (cv->inchord) {
event_error("grace notes not allowed within chord");
return;
};
if (cv->ingrace) {
event_error("nested grace notes not allowed");
return;
};
cv->gracebeamroot = NULL;
cv->gracebeamend = NULL;
cv->ingrace = 1;
addfeature(GRACEON, NULL);
}
void event_graceoff()
/* end of grace note(s) */
{
if (!cv->ingrace) {
event_error("No grace notes to close");
return;
};
if (cv->inchord) {
event_error("cannot close grace notes within chord");
return;
};
addfeature(GRACEOFF, NULL);
closegracebeam(cv);
cv->ingrace = 0;
cv->gracebeamroot = NULL;
cv->gracebeamend = NULL;
}
void event_rep1()
/* start of first repeat */
{
addfeature(REP1, NULL);
}
void event_rep2()
/* start of second repeat */
{
addfeature(REP2, NULL);
}
void event_playonrep(s)
char* s;
/* play on repeat(s) X - where X can be a list */
{
addfeature(PLAY_ON_REP, addstring(s));
}
void event_broken(type, mult)
/* handles > >> >>> < << <<< in the abc */
int type, mult;
{
if (cv->inchord) {
event_error("Broken rhythm not allowed in chord");
} else {
if (cv->ingrace) {
event_error("Broken rhythm not allowed in grace notes");
} else {
cv->brokentype = type;
cv->brokenmult = mult;
cv->brokenpending = 0;
};
};
}
void event_tuple(n, q, r)
int n, q, r;
/* Start of a tuple has been encountered (e.g. triplet) */
/* Meaning is "play next r notes at q/n of notated value" */
/* where all 3 exist, otherwise r defaults to n and ratio */
/* is deduced from standard rules if q is missing */
{
if (cv->tuplenotes != 0) {
event_error("tuple within tuple not allowed");
return;
};
if (r != 0) {
cv->tuplenotes = r;
} else {
cv->tuplenotes = n;
};
if (q != 0) {
cv->tuplefactor.num = q;
cv->tuplefactor.denom = n;
} else {
cv->tuplefactor.denom = n;
if ((n == 2) || (n == 4) || (n == 8)) cv->tuplefactor.num = 3;
if ((n == 3) || (n == 6)) cv->tuplefactor.num = 2;
if ((n == 5) || (n == 7) || (n == 9)) {
if ((cv->barlen.num % 3) == 0) {
cv->tuplefactor.num = 3;
} else {
cv->tuplefactor.num = 2;
};
};
};
cv->thistuple = newtuple(cv->tuplefactor.denom, cv->tuplefactor.num,
cv->tuplenotes, n);
addfeature(TUPLE, cv->thistuple);
}
void event_startinline()
{
}
void event_closeinline()
{
}
void event_handle_gchord(s)
char* s;
/* Guitar/Accompaniment chord placed in linked list for association */
/* with next suitable note */
{
if (cv->gchords_pending == NULL) {
cv->gchords_pending = newlist();
};
if (*s == '_') {
if (cv->instructions_pending == NULL) {
cv->instructions_pending = newlist();
};
addtolist(cv->instructions_pending, addstring(s+1));
} else {
addtolist(cv->gchords_pending, addstring(s));
};
}
void event_handle_instruction(s)
char* s;
/* An instruction (! !) has been encountered */
{
char* inst;
static char segno[3] = ":s";
static char coda[3] = ":c";
struct dynamic *psaction;
int done;
done = 0;
inst = s;
if (strcmp(s, "fermata") == 0)
{
decorators_passback[4] =1;
/* don't show !fermata!. Treat it like H in music line */
return;
}
if (strcmp(s, "trill") == 0)
{
decorators_passback[6] =1;
/* don't show !trill!. Treat it like T in music line */
return;
}
if (strcmp(s, "segno") == 0) {
inst = segno;
done = 1;
};
if (strcmp(s, "coda") == 0) {
inst = coda;
done = 1;
};
if (done == 1) {
if (cv->instructions_pending == NULL) {
cv->instructions_pending = newlist();
};
addtolist(cv->instructions_pending, addstring(inst));
return;
}
if (strcmp(s,"red") == 0)
{
psaction = (struct dynamic*) checkmalloc(sizeof(struct note));
psaction->color = 'r';
addfeature(DYNAMIC,psaction);
}
if (strcmp(s,"black") == 0)
{
psaction = (struct dynamic*) checkmalloc(sizeof(struct note));
psaction->color = 'b';
addfeature(DYNAMIC,psaction);
}
}
struct slurtie* resolve_slur(struct feature* lastnote)
/* when an end-of-slur marker ')' is found, this routine works out */
/* where the other end of the slur was */
{
int i;
int resolved;
struct slurtie* s;
resolved = 0;
if (lastnote != NULL) {
for (i=0; i<cv->slurcount; i++) {
if ((resolved == 0) && (cv->slur_place[i]->begin != NULL) &&
(cv->slur_place[i]->begin != lastnote)) {
resolved = 1;
cv->slur_place[i]->end = lastnote;
s = cv->slur_place[i];
cv->slur_place[i] = cv->slur_place[cv->slurcount-1];
cv->slurcount = cv->slurcount - 1;
};
};
};
if (resolved == 0) {
event_error("Could not find start of slur to match close slur");
s = NULL;
};
return(s);
}
static void startslurs(struct feature* firstnote)
/* When a note is found after a (, set note to be start of slur */
/* Note may be the start of more than one slur */
{
int i;
for (i=0; i<cv->slurcount; i++) {
if (cv->slur_place[i]->begin == NULL) {
cv->slur_place[i]->begin = firstnote;
};
};
}
void event_sluron(t)
int t;
/* start of slur */
{
struct slurtie* s;
s = newslurtie();
addfeature(SLUR_ON, s);
cv->slurpending = 1;
if (cv->slurcount < MAX_SLURS) {
cv->slur_place[cv->slurcount] = s;
cv->slurcount = cv->slurcount+1;
} else {
event_error("Static limit on number of slurs exceeded");
};
}
void event_sluroff(t)
int t;
/* end of slur */
{
struct slurtie* s;
s = resolve_slur(cv->lastnote);
addfeature(SLUR_OFF, s);
}
static void resolve_ties(struct feature* f)
/* try to match up note to previous tied note */
{
struct feature* ft;
struct slurtie* s;
struct note* m;
struct note* n;
int i, j;
n = f->item.voidptr;
for (i=0; i<cv->tiespending; i++) {
ft = cv->tie_place[i]; /* pointer to TIE feature */
s = ft->item.voidptr;
ft = s->begin; /* pointer to NOTE feature */
m = ft->item.voidptr;
if (m->y == n->y) { /* pitch match found */
s->end = f;
j = cv->tiespending;
cv->tie_place[i] = cv->tie_place[j-1];
cv->tie_status[i] = cv->tie_status[j-1];
cv->tiespending = j-1;
};
};
}
static void advance_ties()
/* deal with unresolved tied notes as musical time advances */
{
int i, j;
for (i=0; i<cv->tiespending; i++) {
cv->tie_status[i]++;
};
i = 0;
j = cv->tiespending;
while (i < j) {
if (cv->tie_status[i] >= 2) {
event_error("No note to tie to");
cv->tie_place[i] = cv->tie_place[j-1];
cv->tie_status[i] = cv->tie_status[j-1];
j = j - 1;
} else {
i = i + 1;
};
};
cv->tiespending = j;
}
void event_tie()
/* tie encountered in the abc */
{
struct slurtie* s;
struct feature* place;
int i;
if ((cv->lastnote == NULL)||(cv->lastnote->type != NOTE)) {
event_error("No note to tie");
} else {
s = newslurtie();
place = addfeature(TIE, s);
s->begin = cv->lastnote;
cv->lastnote = NULL;
i = cv->tiespending;
if (i < MAX_TIES) {
cv->tie_place[i] = place;
cv->tie_status[i] = 0;
cv->tiespending = cv->tiespending + 1;
} else {
event_error("Internal limit on ties exceeded");
};
};
}
void event_lineend(ch, n)
char ch;
int n;
/* Line ending with n copies of special character ch */
{
}
static void lenmul(n, a, b)
/* multiply note length by a/b */
struct feature* n;
int a, b;
{
struct note *anote;
struct rest* arest;
struct fract* afract;
if (n->type == NOTE) {
anote = n->item.voidptr;
afract = &anote->len;
afract->num = afract->num * a;
afract->denom = afract->denom * b;
reducef(afract);
/* re-calculate base, base_exp and dots */
anote->dots = count_dots(&anote->base, &anote->base_exp,
anote->len.num, anote->len.denom);
};
if (n->type == REST) {
arest = n->item.voidptr;
afract = &arest->len;
afract->num = afract->num * a;
afract->denom = afract->denom * b;
reducef(afract);
/* re-calculate base, base_exp and dots */
arest->dots = count_dots(&arest->base, &arest->base_exp,
arest->len.num, arest->len.denom);
};
}
struct fract* getlenfract(struct feature *f)
/* find fractional length of NOTE or REST */
{
struct fract *len;
struct note *anote;
struct rest *arest;
len = NULL;
if (f->type == NOTE) {
anote = f->item.voidptr;
len = &(anote->len);
};
if (f->type == REST) {
arest = f->item.voidptr;
len = &(arest->len);
};
return(len);
}
static void brokenadjust()
/* adjust lengths of broken notes */
{
int num1, num2, denom12;
struct feature* j;
struct fract* fr1;
struct fract* fr2;
int temp;
int failed;
int done;
switch(cv->brokenmult) {
case 1:
num1 = 3;
num2 = 1;
break;
case 2:
num1 = 7;
num2 = 1;
break;
case 3:
num1 = 15;
num2 = 1;
break;
default:
num1 = num2 = 1; /* [SDG] 2020-06-03 */
};
denom12 = (num1 + num2)/2;
if (cv->brokentype == LT) {
temp = num1;
num1 = num2;
num2 = temp;
};
failed = 0;
if ((cv->laststart == NULL) || (cv->lastend == NULL) ||
(cv->thisstart == NULL) || (cv->thisend == NULL)) {
failed = 1;
} else {
/* check for same length notes */
fr1 = getlenfract(cv->laststart);
fr2 = getlenfract(cv->thisstart);
/*
fr1 = cv->laststart->item.voidptr;
fr2 = cv->thisstart->item.voidptr;
*/
if ((fr1->num * fr2->denom) != (fr2->num * fr1->denom)) {
failed = 1;
};
};
if (failed) {
event_error("Cannot apply broken rhythm");
} else {
/*
printf("Adjusting %d to %d and %d to %d\n",
cv->laststart, cv->lastend, cv->thisstart, cv->thisend);
*/
j = cv->laststart;
done = 0;
while (done == 0) {
lenmul(j, num1, denom12);
done = (j == cv->lastend);
j = j->next;
};
j = cv->thisstart;
done = 0;
while (done == 0) {
lenmul(j, num2, denom12);
done = (j == cv->thisend);
j = j->next;
};
};
}
static void marknotestart(struct feature* place)
/* voice data structure keeps a record of last few notes encountered */
/* in order to process broken rhythm. This is called at the start of */
/* a note or chord */
{
cv->laststart = cv->thisstart;
cv->lastend = cv->thisend;
cv->thisstart = place;
}
static void marknoteend(struct feature* place)
/* voice data structure keeps a record of last few notes encountered */
/* in order to process broken rhythm. This is called at the end of */
/* a note or chord */
{
cv->thisend = place;
if (cv->brokenpending != -1) {
cv->brokenpending = cv->brokenpending + 1;
if (cv->brokenpending == 1) {
brokenadjust();
cv->brokenpending = -1;
};
};
}
static void marknote(struct feature* place)
/* when handling a single note, not a chord, marknotestart() and */
/* marknoteend() can be called together */
{
marknotestart(place);
marknoteend(place);
}
static void markchord(struct feature* chordplace)
/* find start and end of chord for applying broken rhythm */
{
struct feature* first;
struct feature* last;
first = chordplace->next;
last = first;
while ((last->next != NULL)&&(last->next->type==NOTE)) {
last = last->next;
};
marknotestart(first);
marknoteend(last);
}
void event_chord()
/* handles old '+' notation which marks the start and end of each chord */
{
if (cv->inchord) {
event_chordoff(1,1);
} else {
event_chordon(dummydecorator);
};
}
void event_chordon(int chorddecorators[])
/* start of a chord */
/* the array chorddecorators is not used yet. */
{
if (cv->inchord) {
event_error("nested chords found");
return;
};
cv->inchord = 1;
cv->chordcount = 0;
cv->thischord = newchord();
cv->chordplace = addfeature(CHORDON, cv->thischord);
}
void event_ignore () { }; /* [SS] 2018-12-21 */
void fix_enclosed_note_lengths(struct feature* chordplace,
int chord_n, int chord_m, int * base, int * base_exp)
{
struct feature* f;
struct note* anote;
if (chord_n ==1 && chord_m ==1) return;
f = chordplace->next;
anote = f->item.voidptr;
/* remove old note length from barcount */
addfractions(&cv->barcount, -anote->len.num, anote->len.denom);
while ((f != NULL)&&((f->type==NOTE)||(f->type=CHORDNOTE))) {
anote = f->item.voidptr;
/* remove old note length from barcount */
setfract(&anote->len, chord_n*cv->unitlen.num, chord_m*cv->unitlen.denom);
reducef(&anote->len);
/*printf("NOTE %c%c %d / %d\n", anote->accidental, anote->pitch,
anote->len.num, anote->len.denom);
*/
anote->dots = count_dots(&anote->base, &anote->base_exp,
anote->len.num, anote->len.denom);
f = f->next;
*base = anote->base;
*base_exp = anote->base_exp;
}
/* and new note length to barcount */
addfractions(&cv->barcount, anote->len.num, anote->len.denom);
}
void event_chordoff(int chord_n, int chord_m)
/* end of a chord */
{
struct feature* ft;
struct chord* thechord;
struct note* firstnote;
int base,base_exp;
if (!cv->inchord) {
event_error("no chord to close");
return;
};
ft = cv->chordplace;
if ((ft != NULL) && (ft->next != NULL) && (ft->next->type == NOTE)) {
thechord = ft->item.voidptr;
firstnote = ft->next->item.voidptr;
/* beaming for 1st note in chord */
beamitem(NOTE, firstnote, ft->next);
markchord(ft);
thechord->base = firstnote->base;
thechord->base_exp = firstnote->base_exp;
} else {
thechord = NULL; /* [SDG] 2020-06-04 */
event_error("mis-formed chord");
};
if (cv->chordplace) {
fix_enclosed_note_lengths(cv->chordplace,chord_n,chord_m,&base,&base_exp);
if (chord_n != 1 || chord_m != 1) {
thechord->base = base;
thechord->base_exp = base_exp;
}
}
cv->inchord = 0;
cv->thischord = NULL;
cv->chordplace = NULL;
advance_ties();
addfeature(CHORDOFF, NULL);
}
/* just a stub to ignore 'y' */
void event_spacing(n, m)
int n,m;
{
}
void xevent_rest(n, m, multi)
int n, m, multi;
/* A rest has been encountered in the abc */
/* multi is 0 for ordinary rests or count for multibar rests */
{
struct feature* restplace;
if (cv->ingrace) {
event_warning("rest in grace notes ignored");
return;
};
if (cv->inchord) {
event_warning("rest in chord ignored");
return;
};
if ((multi > 0) && (cv->tuplenotes > 0)) {
event_error("Multiple bar rest not allowed in tuple");
};
advance_ties();
restplace = addfeature(REST, newrest(n*cv->unitlen.num,
m*cv->unitlen.denom, multi));
if (cv->slurpending) {
startslurs(restplace);
cv->slurpending = 0;
};
cv->lastnote = restplace;
if (cv->inchord) {
cv->chordcount = cv->chordcount + 1;
} else {
marknote(restplace);
};
if ((!cv->ingrace) && (!cv->inchord || (cv->chordcount == 1))) {
if (cv->tuplenotes == 0) {
if (multi == 0) {
addunits(&cv->barcount, n, m);
};
} else {
addunits(&cv->barcount, n*cv->tuplefactor.num, m*cv->tuplefactor.denom);
cv->thistuple->beamed = 0;
cv->tuplenotes = cv->tuplenotes - 1;
if (cv->tuplenotes == 0) {
cv->thistuple = NULL;
};
};
};
}
void event_rest(decorators,n,m,type)
int n, m,type;
int decorators[DECSIZE];
/* A rest has been encountered in the abc */
{
xevent_rest(n, m, 0);
}
void event_mrest(n,m,c)
int n, m;
char c; /* [SS] 2017-04-19 to distinguish X from Z in abc2abc */
/* A multiple bar rest has been encountered in the abc */
{
xevent_rest(1, 1, n);
}
void event_note(decorators, clef, xaccidental, xmult, xnote, xoctave, n, m)
int decorators[DECSIZE];
cleftype_t *clef; /* [JA] 2020-10-19 */
int xmult;
char xaccidental, xnote;
int xoctave, n, m;
/* note found in abc */
{
struct note* nt;
struct feature* noteplace;
struct chord* thechord;
int pitchval;
nt = newnote(decorators, clef, xaccidental, xmult, xnote, xoctave,
n * cv->unitlen.num, m * cv->unitlen.denom);
nt->tuplenotes = cv->tuplenotes;
noteplace = addfeature(NOTE, nt);
cv->lastnote = noteplace;
resolve_ties(noteplace);
if (cv->slurpending) {
startslurs(noteplace);
cv->slurpending = 0;
};
if (!cv->inchord) {
marknote(noteplace);
advance_ties();
} else {
thechord = cv->thischord;
pitchval = notenum(xoctave, xnote, clef);
if (cv->chordcount == 0) {
thechord->ytop = pitchval;
thechord->ybot = pitchval;
} else {
if (pitchval > thechord->ytop) {
thechord->ytop = pitchval;
};
if (pitchval < thechord->ybot) {
thechord->ybot = pitchval;
};
};
cv->chordcount = cv->chordcount + 1;
};
if ((!cv->ingrace) &&
(!cv->inchord || (cv->chordcount == 1))) {
if (cv->tuplenotes == 0) {
addunits(&cv->barcount, n, m);
} else {
addunits(&cv->barcount, n*cv->tuplefactor.num, m*cv->tuplefactor.denom);
if (nt->base_exp > -3) {
cv->thistuple->beamed = 0;
};
cv->tuplenotes = cv->tuplenotes - 1;
if (cv->tuplenotes == 0) {
cv->thistuple = NULL;
/* prevent beaming from tuple to non-tuple notes */
addfeature(NOBEAM, NULL);
};
};
};
}
/* these functions are here to satisfy the linker */
void event_microtone(int dir, int a, int b)
{
}
void event_temperament(char *line) {
}
void event_normal_tone()
{
}
void event_info_key(key, value)
char* key;
char* value;
/* handles a (key,value) pair found in an I: field */
{
int num;
if (strcmp(key, "clef")==0) {
cleftype_t new_clef; /* [JA] 2020-10-19 */
int valid_clef;
init_new_clef (&new_clef);
valid_clef = get_standard_clef (value, &new_clef);
if (!valid_clef) {
valid_clef = get_extended_clef_details (value, &new_clef);
}
if (valid_clef) {
event_clef (value, &new_clef);
}
};
if (strcmp(key, "octave")==0) {
num = readsnumf(value);
event_octave(num,0);
};
}
int main(argc,argv)
int argc;
char *argv[];
{
char *filename;
int i;
oldchordconvention = 0;
for (i=0;i<DECSIZE;i++) decorators_passback[i]=0;
event_init(argc, argv, &filename);
if (argc < 2) {
/* printf("argc = %d\n", argc); */
} else {
init_abbreviations();
parsefile(filename);
free_abbreviations();
};
return(0);
}
Reference in New Issue View Git Blame Copy Permalink