//
// Programmer: John Howard <John.B.Howard@asu.edu>
// Creation Date: A long time ago (circa 1990)
// Filename: rmusic.c
// Syntax: C
//
// Programmer: Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Filename: pe2score.c
// Last Modified: Tue Aug 15 01:18:37 PDT 2006
// Extracted core portions of rmusic.c for converting
// Plaine & Easie music notation into SCORE input data.
//
// Description: Converts RISM entries into SCORE input data which
// can be used to create graphical PostScript music
// notation of incipits.
//
//
/*
From: John B Howard [mailto:John_Howard@harvard.edu]
Sent: Tuesday, February 10, 2004 2:37 AM
To: esfield@stanford.edu
Subject: Source code for RISM P&E to Score converter
I'm attaching a zipped file with a couple ANSI C source code files that
I used to convert RISM's P&E code to a Score input file. Unfortunately
the documentation for these files is not easily accessible, but it should
be possible to figure out the program operation and logic. The critical
issue is probably the format of the input file.
There were two possible formats that had to be dealt with:
(1) SPIRES standard format, and I have at least a sample input file
in the zip file of that.
(2) The format used by the sequential data file on the RISM A/II CDROM.
This file had tagged data on sequential lines that would not exceed 256
bytes. Syntax was: three-digit field code followed by data; if a field
exceeded 256 characters it would continue on the next line, with three
space characters occupying the first three bytes of the continuation.
(It might still be possible to run this against the data on the CDROM --
one of the problems I had, however, was that RISM constantly changed
their data standard and made 'enhancements' to the P&E encoding(which
was also notoriously non-syntactical)).
Choose the appropriate command-line flags and it should output as you
specify -- they're explained in the source or output if the compiled
program is run with no arguments. I typically would run it with first with
the verbose option to identify problems without actually writing an output
file. Another command-line flag controles whether Score output EPS files
... I found that I had to specify an absolute length for the incipit,
otherwise the tool I used to convert the EPS files to bitmaps
would vary the relative size of the images ... which was really ugly
to look at on screen!
*/
#include <stdio.h>
#include <string.h>
#include "Options.h"
#ifndef OLDCPP
#include <sstream>
#define SSTREAM stringstream
#define CSTRING str().c_str()
using namespace std;
#else
#ifdef VISUAL
#include <strstrea.h> /* for windows 95 */
#else
#include <strstream.h>
#endif
#define SSTREAM strstream
#define CSTRING str()
#endif
Options options;
void spires2rism(FILE * ifp, FILE * ofp);
int MakeKeySignature(char *s);
int MakeTimeSignature(char *s);
int MakeClef(char *s);
void MakeOctave(char *s);
void MakeRhythm(char *s);
void lstr(char *s, int n);
void rstr(char *s, int n);
char* convertPe2ScoreInput(char* output, const char* input);
void checkOptions(Options& opts, int argc, char* argv[]);
void usage(const char* command);
void example(void);
void convert(SSTREAM& output, const char* input);
///////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv) {
// process the command-line options
checkOptions(options, argc, argv);
char *data = NULL;
if (options.getArgCount() != 1) {
usage(options.getCommand());
exit(1);
} else {
convertPe2ScoreInput(data, options.getArg(1));
}
std::cout << data << endl;
return 0;
}
///////////////////////////////////////////////////////////////////////////
//////////////////////////////
//
// convertPe2ScoreInput -- convert a Plaine & Easie string of music
// into SCORE input data which will be converted to PostScript
// graphical music notation.
//
char* convertPe2ScoreInput(char *data, const char* input) {
SSTREAM output;
convert(output, input);
output << ends;
int length = strlen(output.CSTRING);
data = new char[length+1];
strcpy(data, output.CSTRING);
return data;
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void convert(SSTREAM& output, const char* input) {
char id[13], incipit_id[15];
int verbose = 0;
int tclef_flag;
int field_cnt = 0;
int next_flag = 0;
int startpos = 0;
int i = 0;
int rc = 1;
int err_cnt = 0;
int w;
int rism = 0;
int beam_cnt = 0;
int proof = 0;
int print_flag = 0;
int beam_flag = 0;
int format = 0;
// extern int tclef_flag;
int wmn_flag = 0;
char tmp[2056];
char key_signature[26];
int TotalIncipits = 0;
int TotalRecords = 0;
int TotalErrors = 0;
int TotalErrorRecords = 0;
char MusicOut[1028];
char RhythmOut[562];
char BeamsOut[256];
char SlursOut[256];
char ur_clef[18];
char ur_timesig[18];
char ur_keysig[18];
char start_clef[18];
char start_timesig[18];
char start_keysig[18];
char FileName[17];
char MarksOut[128];
char subdir[128];
char library[56];
char country[12];
int c;
strcpy(incipit_id, "1.1.1");
strcpy(key_signature, "");
i = 0;
++TotalRecords;
i = 0;
field_cnt = 1;
next_flag = 0;
// char* country = country code
// char* library = library code
// 789: Component incipit (music)
int incno = 0;
int m_flag = 0;
int Serr_flag = 0;
char instrumentation[562];
char role[256];
char tempo[562];
char text[1062];
char clef[18];
char timesig[18];
char ur_music[1062];
char music[1062];
char comment[562];
char inclen[5];
char ex_music[1062];
char keysig[24];
char stitle[2056];
char value[2056];
strcpy(instrumentation, "");
strcpy(role, "");
strcpy(tempo, "");
strcpy(text, "");
strcpy(clef, "");
strcpy(timesig, "");
strcpy(music, "");
strcpy(comment, "");
strcpy(keysig, "");
strcpy(stitle, "");
strcpy(value, "");
incno = 0;
strcpy(timesig, "4/4");
strcpy(clef, "G2");
strcpy(ur_clef, clef);
strcpy(start_clef, clef);
strcpy(music, input);
strcpy(ur_music, music);
/*- begin processing of incipits -*/
/*- process Score notes stage ... -*/
int n, j, o, bar_cnt, cue_flag = 0, chord_flag =
0, rep_flag = 0;
char octave[3], note[3], accidental[3];
char RepFigure[356];
char LastClef[6];
char symbol[12];
char lastsymbol[12];
wmn_flag = 0;
strcpy(LastClef, clef);
strcpy(ur_timesig, timesig);
if ((w = MakeTimeSignature(timesig)) < 0) {
printf
("RISM %s (%s): invalid time signature \"%s\"\n",
id, incipit_id, timesig);
++err_cnt;
Serr_flag = 1;
}
strcpy(start_timesig, timesig);
strcpy(accidental, "");
strcpy(MusicOut, "");
strcpy(symbol, "");
strcpy(lastsymbol, "");
strcpy(keysig, "");
strcpy(ur_keysig, "");
/*- But first, some proofreading ... -*/
int t, beams, exclam, octaves, parens, graces, zrhythm;
char rests[4];
char reg[6];
char duration[6];
char temp[1028];
strcpy(temp, "");
strcpy(reg, "");
strcpy(duration, "");
strcpy(rests, "");
zrhythm = 'z';
exclam = 0;
parens = 0;
graces = 0;
octaves = 0;
beams = 0;
bar_cnt = 1;
int musiclength = strlen(music);
for (n=0; n<musiclength; n++) {
if (music[n] == '*' || music[n] == '%' || /* skip change of */
music[n] == '@' || music[n] == '$') { /* clef, etc. */
n++;
while (music[n] != '*' || music[n] == ' ') {
n++;
}
continue;
}
if (music[n] == ',' || music[n] == '\'') {
octaves = 1;
temp[0] = music[n];
t = 1;
while (music[n + 1] == ',' || music[n + 1] == '\'') {
temp[t++] = music[n++];
}
temp[t] = '\0';
if (strcmp(temp, reg) == 0 && (verbose == 1)) {
cerr << "WARNING: redundant octave register symbol"
<< "( measure " << bar_cnt << ")"
<< endl;
continue;
} else {
strcpy(reg, temp);
continue;
}
}
if (music[n] == '{') ++beams;
if (music[n] == '}') --beams;
if (music[n] == '(') ++parens;
if (music[n] == ')') --parens;
if (music[n] == 'q' && music[n + 1] == 'q') {
++n;
++graces;
}
if (music[n] == 'r') --graces;
if (music[n] == '!') {
if (exclam == 0) ++exclam;
else --exclam;
}
if (isdigit(music[n]) || music[n] == 'g') {
zrhythm = music[n];
temp[0] = music[n];
t = 1;
while (music[n + 1] == '.') temp[t++] = music[n++];
temp[t] = '\0';
if (strcmp(temp, duration) == 0
&& (verbose == 1)) {
printf
("RISM %s (%s, measure %d): redundant duration "
"symbol\n", id, incipit_id, bar_cnt);
} else strcpy(duration, temp);
continue;
}
if (isupper(music[n]) || music[n] == '-') {
if (zrhythm == 'z') {
printf
("RISM %s (%s, measure %d): 1st note or rest "
"has no rhythm\n", id, incipit_id,
bar_cnt);
zrhythm = '4';
++err_cnt;
continue;
}
if (octaves == 0 && isupper(music[n])) {
printf
("RISM %s (%s, measure %d): no octave register "
"at start of incipit\n", id,
incipit_id, bar_cnt);
octaves = 4;
err_cnt++;
continue;
}
}
if (music[n] == '/') {
++bar_cnt;
if (parens > 0) {
printf
("RISM %s (%s measure %d): chain brackets not "
"closed\n", id, incipit_id, bar_cnt);
Serr_flag = 1;
parens = 0;
err_cnt++;
continue;
}
if (parens < 0) {
printf
("RISM %s (%s measure %d): open chain bracket "
"missing\n", id, incipit_id,
bar_cnt);
Serr_flag = 1;
parens = 0;
err_cnt++;
continue;
}
if (graces > 0) {
printf
("RISM %s (%s measure %d): grace-note figure not "
"closed\n", id, incipit_id, bar_cnt);
Serr_flag = 1;
graces = 0;
err_cnt++;
continue;
}
if (graces < 0) {
printf
("RISM %s (%s measure %d): improper start of grace-"
"note figure\n", id, incipit_id,
bar_cnt);
/* Serr_flag = 1; */
graces = 0;
err_cnt++;
continue;
}
if (exclam != 0) {
printf
("RISM %s (%s measure %d): unexpected specification "
"of repeated figure\n", id,
incipit_id, bar_cnt);
/* Serr_flag = 1; */
exclam = 0;
err_cnt++;
continue;
}
if (music[n + 1] == '/')
++n;
continue;
}
if (music[n] == '=') {
int z;
for (z = 0; isdigit(music[n + 1]); n++)
rests[z++] = music[n + 1];
if (z > 0) {
rests[z] = '\0';
bar_cnt = ((bar_cnt - 1) + (atoi(rests)));
z = 0;
}
}
} // end of proofreading loop
///
/// Score notes output stage ...
///
bar_cnt = 1;
if (music[0] == '<') { // other notation type
n = 3;
// white mensural notation:
if (music[0] == 'w') {
wmn_flag = 1;
}
} else {
n = 0;
}
for (; n <= (int)strlen(music); n++) {
if (isdigit(music[n]) || music[n] == 't' ||
music[n] == 'g' || music[n] == '.' ||
music[n] == '{' || music[n] == '}'
|| music[n] == ')') {
continue;
}
switch (music[n]) {
case '!': // ! = repeated figures
strcpy(lastsymbol, "");
if (rep_flag == 0) { // start of figure
strcpy(RepFigure, "");
rep_flag = 1;
continue;
} else { // end figure
strcpy(lastsymbol, "");
if (music[n + 1] != 'f') { // error condition
Serr_flag = 1;
err_cnt++;
printf
("RISM %s (%s, measure %d): repeated figure not "
"followed by \"f\"\n", id,
incipit_id, bar_cnt);
} else { // expand figure
strcat(MusicOut, RepFigure);
while (music[n + 1] == 'f') {
strcat(MusicOut, RepFigure);
++n;
}
rep_flag = 0;
}
}
continue;
case ':':
if (music[n + 3] == ':') {
strcat(MusicOut, "/MRD");
strcpy(lastsymbol, "/MRD");
n = n + 3;
continue;
}
if (music[n + 2] != '\x2f') {
printf("RISM %s (%s, measure %d): invalid "
"encoding of repeat sign\n", id,
incipit_id, bar_cnt);
err_cnt++;
Serr_flag = 1;
}
strcat(MusicOut, "/ML"); // JBH change to /ML
strcpy(lastsymbol, "/MxiLR");
n = n + 2;
continue;
case '-': // rests
chord_flag = 0;
if (rep_flag == 1) strcat(RepFigure, "/R");
else {
strcat(MusicOut, "/R");
strcpy(lastsymbol, "/R");
}
continue;
case '\x2f': // barlines
chord_flag = 0;
++bar_cnt;
if (music[n + 1] == '\x2f'
&& music[n + 2] != ':') {
strcat(MusicOut, "/MD");
strcpy(lastsymbol, "/MD");
n = n + 1;
continue;
}
if (music[n + 1] == '\x2f'
&& music[n + 2] == ':') {
strcat(MusicOut, "/MR"); // JBH change to MR
strcpy(lastsymbol, "/MR");
n = n + 2;
continue;
}
if (rep_flag == 1) {
printf
("RISM %s (%s, measure %d): repeated figure "
"spans the barline\n", id, incipit_id,
bar_cnt);
err_cnt++;
Serr_flag = 1;
}
strcat(MusicOut, "/M");
strcpy(lastsymbol, "/M");
continue;
case 'q': // cue-sized notes
if (music[n + 1] == 'q') {
++n;
cue_flag = 1;
if (rep_flag == 1)
strcat(RepFigure, "/SU/Q+");
else {
strcat(MusicOut, "/SU/Q+");
strcpy(lastsymbol, "/SU/Q+");
}
}
continue;
case 'r': // end cue-sized notes
cue_flag = 0;
if (rep_flag == 1)
strcat(RepFigure, "/Q0/SO");
else {
strcat(MusicOut, "/Q0/SO");
strcpy(lastsymbol, "/Q0/SO");
}
continue;
case '\'':
for (j = 0; music[n] == '\''; n++) {
octave[j++] = music[n];
}
octave[j] = '\0';
--n;
MakeOctave(octave);
continue;
case ',':
for (j = 0; music[n] == ','; n++) {
octave[j++] = music[n];
}
octave[j] = '\0';
--n;
MakeOctave(octave);
continue;
case 'n':
accidental[0] = 'N';
accidental[1] = '\0';
continue;
case 'b':
accidental[0] = 'F';
if (music[n + 1] == 'b') {
++n;
accidental[1] = 'F';
accidental[2] = '\0';
} else {
accidental[1] = '\0';
}
continue;
case 'x':
accidental[0] = 'S';
if (music[n + 1] == 'x') {
++n;
accidental[1] = 'S';
accidental[2] = '\0';
} else {
accidental[1] = '\0';
}
continue;
case '=':
chord_flag = 0;
if (music[n + 1] == '\x2f') {
strcat(MusicOut, "/RW");
strcpy(lastsymbol, "/RW");
continue;
}
for (o = 0; isdigit(music[n + 1]);) {
tmp[o++] = music[++n];
}
tmp[o] = '\0';
strcat(strcat(MusicOut, "/R"), tmp);
strcat(strcpy(lastsymbol, "/R"), tmp);
bar_cnt = (bar_cnt + (atoi(tmp) - 1));
continue;
case 'i':
chord_flag = 0;
strcat(MusicOut, "/RP");
strcpy(lastsymbol, "/RP");
continue;
case '(':
if (music[n + 1] == '=' && music[n + 2] == ')') {
strcat(MusicOut, "/RF");
strcpy(lastsymbol, "/RF");
n = n + 2;
continue;
}
if (music[n + 1] == '-' && music[n + 2] == ')') {
strcat(MusicOut, "/RF");
strcpy(lastsymbol, "/RF");
n = n + 2;
continue;
}
continue;
case ';': // tuplet number
while (isdigit(music[++n]));
continue;
case '^': // U.S. RISM chords
if (rep_flag == 1) {
strcat(RepFigure, ":");
chord_flag = 1;
} else {
chord_flag = 1;
strcat(MusicOut, ":");
strcat(lastsymbol, ":"); // chg from strcpy -- JBH
} // so chords won't repeat
continue;
case '%': // change of clef
chord_flag = 0;
for (o = 0; music[++n] != ' ';) {
clef[o++] = music[n];
}
clef[o] = '\0';
if (MakeClef(clef) < 0) {
printf
("RISM %s (%s, measure %d): invalid clef \"%s\"\n",
id, incipit_id, bar_cnt, clef);
++err_cnt;
Serr_flag = 1;
continue;
}
if (strcmp(clef, LastClef) != 0) {
strcpy(LastClef, clef);
if (rep_flag == 1)
strcat(strcat(RepFigure, "/"), clef);
else {
strcat(strcat(MusicOut, "/"), clef);
strcpy(lastsymbol, clef);
}
}
continue;
case '@': // change of time signature
chord_flag = 0;
for (o = 0; music[++n] != ' ';) {
timesig[o++] = music[n];
}
timesig[o] = '\0';
if ((w = MakeTimeSignature(timesig)) < 0) {
printf("RISM %s (%s): invalid time signature \"%s\"\n",
id, incipit_id, timesig);
++err_cnt;
Serr_flag = 1;
}
if (rep_flag == 1)
strcat(RepFigure, timesig);
else {
strcat(MusicOut, timesig);
strcpy(lastsymbol, "XXX");
}
continue;
case '$': // change of key signature
chord_flag = 0;
for (o = 0; music[++n] != ' ';) {
keysig[o++] = music[n];
}
keysig[o] = '\0';
MakeKeySignature(keysig);
if (strlen(keysig) > 0) { // if there's a key signature
if (rep_flag == 1)
/* August 1996: don't need the slash */
/* strcat(strcat(RepFigure,"/"),keysig); */
strcat(RepFigure, keysig);
else {
strcat(MusicOut, keysig);
strcpy(lastsymbol, keysig);
}
}
continue;
case '[':
/*- used with barlines only! -*/
if (music[n + 2] != ']' && music[n + 1] != '/') {
printf
("RISM %s: unexpected use of brackets\n",
id);
err_cnt++;
continue;
}
if (rep_flag == 1) {
printf("RISM %s (%s, measure %d): repeated "
"figure spans more than one measure\n",
id, incipit_id, bar_cnt);
err_cnt++;
Serr_flag = 1;
}
strcat(MusicOut, "/MS");
strcpy(lastsymbol, "/MS");
++n;
continue;
} // end of switch
if (isupper(music[n])) { // notes
note[0] = music[n];
note[1] = '\0';
if (rep_flag == 0) {
strcat(strcat (strcpy(symbol, note), accidental), octave);
if (strcmp(symbol, lastsymbol) == 0 && music[n + 1] != '^'
&& chord_flag == 0) {
strcat(MusicOut, "/");
} else {
if (chord_flag == 0) {
strcat(strcat(MusicOut, "/"), symbol);
strcat(lastsymbol, ""); // JBH
} else {
strcat(MusicOut, symbol);
chord_flag = 0;
strcpy(lastsymbol, "XXX"); // JBH - chg fr symbol
}
}
strcpy(accidental, "");
} else {
if (chord_flag == 0) {
strcat(strcat(RepFigure, "/"), note);
} else {
strcat(RepFigure, note);
chord_flag = 0;
}
strcat(strcat(RepFigure, accidental),
octave);
strcpy(accidental, "");
}
}
}
// now clean pitch stage data ...
int LastOctave = 0;
strcpy(tmp, MusicOut);
strcpy(MusicOut, "");
for (n = 0, j = 0; n <= (int)strlen(tmp); n++) { // avoid counting rests as
// octave registers
if (tmp[n] == 'R' && isdigit(tmp[n + 1])) {
MusicOut[j++] = tmp[n++];
while (isdigit(tmp[n]))
MusicOut[j++] = tmp[n++];
--n;
continue;
}
if (isdigit(tmp[n])) {
if (tmp[n + 1] == ' ' || tmp[n - 1] == ' '
|| tmp[n + 2] == ' ') {
MusicOut[j++] = tmp[n];
continue;
}
if (tmp[n] == LastOctave) {
continue;
} else {
LastOctave = tmp[n];
}
}
MusicOut[j++] = tmp[n];
}
MusicOut[j] = '\0';
strcat(strcat(strcpy(tmp, start_clef), start_keysig),
start_timesig);
strcat(tmp, MusicOut);
strcat(strcpy(MusicOut, tmp), "/MI;");
// end Score notes stage
// process Score rhythm stage ...
cue_flag = 0;
rep_flag = 0;
int TupletCnt = 0;
int grace_flag = 0;
int tuplet_flag = 0;
int pc = 0;
char rhythm[6][6];
strcpy(RhythmOut, "");
for (n = 0; n <= (int)strlen(music); n++) {
if (music[n] == 't' ||
music[n] == '{' || music[n] == '}'
|| music[n] == ':' || music[n] == 'x'
|| music[n] == 'b' || music[n] == 'n'
|| music[n] == '+' || music[n] == '\''
|| music[n] == ',' || music[n] == '['
|| music[n] == ']' || music[n] == '\x2f') {
continue;
}
/* if (isdigit(music[n])) { */
if (rc == 1)
pc = 0;
if (rc > 1 && pc < rc)
++pc;
if (rc > 1 && pc == rc)
pc = 0;
if (isdigit(music[n])) {
for (pc = 0, rc = 0; isdigit(music[n]);
pc++, rc++, n++) {
if (music[n + 1] == '(' && music[n + 3] != ')' && music[n + 4] != ')') {
/*- tuplets -*/
TupletCnt = music[n];
pc = 0;
continue;
}
rhythm[pc][0] = music[n];
rhythm[pc][1] = '\0';
MakeRhythm(rhythm[pc]);
while (music[n + 1] == '.') {
strcat(rhythm[pc], ".");
++n;
}
}
--n;
continue;
}
if (isupper(music[n]) || music[n] == '-') {
/*- note values -*/
if (rep_flag == 0) {
if (tuplet_flag == 0) {
if (grace_flag == 0) {
if (cue_flag == 1)
strcat(strcat(RhythmOut, "/"), "G");
else
strcat(strcat(RhythmOut, "/"),
rhythm[pc]);
} else {
if (cue_flag == 0)
grace_flag = 0;
strcat(RhythmOut, "/G");
}
continue;
} else {
/*- tuplet_flag == 1 -*/
if (grace_flag == 0) {
if (rhythm[pc][0] == '3'
&& rhythm[pc][1] == '2')
strcat(RhythmOut, "/48");
else
strcat(strcat(RhythmOut, "/T"),
rhythm[pc]);
} else {
if (cue_flag == 0)
grace_flag = 0;
strcat(RhythmOut, "/G");
}
continue;
}
} else {
if (tuplet_flag == 0) {
if (grace_flag == 0)
strcat(strcat(RepFigure, "/"),
rhythm[pc]);
else {
if (cue_flag == 0)
grace_flag = 0;
strcat(RepFigure, "/G");
}
} else {
strcat(strcat(RepFigure, "/T"),
rhythm[pc]);
}
continue;
}
}
if (music[n] == '%' || music[n] == '@'
|| music[n] == '$') {
while (music[++n] != ' ');
continue;
}
switch (music[n]) {
case '^':
for (; n <= (int)strlen(music); n++) {
if (isupper(music[n]))
break;
}
continue;
case 'g':
grace_flag = 1;
continue;
case '!': // repeated figures
;
if (rep_flag == 0) { // start figure
strcpy(RepFigure, "");
rep_flag = 1;
} else { // end figure
// expand figure
strcat(RhythmOut, RepFigure);
while (music[n + 1] == 'f') {
strcat(RhythmOut, RepFigure);
++n;
}
rep_flag = 0;
}
continue;
case '(':
if (music[n + 1] == '-') {
if (rep_flag == 0) {
strcat(strcat(RhythmOut, "/"),
rhythm[pc]);
n = n + 2;
continue;
} else {
strcat(strcat(RepFigure, "/"),
rhythm[pc]);
n = n + 2;
continue;
}
} else if (music[n + 1] == '=') {
strcat(RhythmOut, "/H");
n = n + 2;
continue;
} // so it must be a tuplet figure ...
if (music[n + 2] != ')' && music[n + 3] != ')')
tuplet_flag = 1;
continue;
case 'q': // cue-sized notes
if (music[n + 1] != 'q') { // appogiatura
if (rep_flag == 0) {
strcat(RhythmOut, "/G");
} else {
strcat(RepFigure, "/G");
}
// move to the note it applies to ...
// Dec. 24, 1995: this code prevents value
// of the appogiature from being passed on ...
for (++n, j = 0; n <= (int)strlen(music); n++) {
if (isdigit(music[n])) {
rhythm[pc][0] = music[n];
rhythm[pc][1] = '\0';
MakeRhythm(rhythm[pc]);
while (music[n + 1] == '.') {
strcat(rhythm[pc], ".");
n++;
}
}
if (isupper(music[n])) {
break;
}
}
continue;
} else { // qq ... r construction
++n;
grace_flag = 1; // JBH98
cue_flag = 1;
}
continue;
case 'r': // end cue-sized notes
cue_flag = 0;
grace_flag = 0; // JBH98
continue;
case '=':
while (isdigit(music[n + 1]))
++n;
strcat(RhythmOut, "/W");
continue;
case 'i':
strcat(RhythmOut, "/W");
continue;
case ';': // tuplet number
tuplet_flag = 0;
while (isdigit(music[++n]));
continue;
case ')':
if (tuplet_flag == 1)
tuplet_flag = 0;
continue;
case '[': // used with barlines only!
continue;
} // end of switch
}
for (o = 0, j = 0; o <= (int)strlen(RhythmOut); o++) {
if (o > 0) {
temp[j++] = RhythmOut[o];
}
}
temp[j] = '\0';
strcpy(RhythmOut, temp);
strcat(RhythmOut, ";");
// end Score rhythm stage
// expand the incipit
printf("GOT HERE J9\n");
int p, q, r;
for (n = 0, o = 0, p = 0; n <= (int)strlen(music); n++) {
if (music[n] == '^') {
for (; n <= (int)strlen(music); n++) {
if (isupper(music[n])) {
break;
}
}
continue;
}
if (music[n] == '!') {
for (++n, p = 0; n <= (int)strlen(music); n++) {
if (music[n] == '!') {
break;
} else {
if (music[n] == '%' || music[n] == '@' ||
music[n] == '$') {
while (music[++n] != ' ');
continue;
}
if (music[n] == '^') { // JBH, Jan 2 1996
for (; n <= (int)strlen(music) && music[n] != '!'; n++) {
if (isupper(music[n])) {
++n;
break;
}
}
} /*= IF -*/
RepFigure[p++] = music[n];
ex_music[o++] = music[n];
}
}
RepFigure[p] = '\0';
while (music[++n] == 'f') {
for (r = 0; r < (int)strlen(RepFigure); r++) {
ex_music[o++] = RepFigure[r];
}
}
strcpy(RepFigure, "");
--n; // bug fix, Dec 16 1995
continue;
}
if (music[n] == '%' || music[n] == '@' ||
music[n] == '$' || music[n] == '*') {
++n;
while (music[n] != ' ' && music[n] != '*'
&& music[n] != '\0')
++n;
continue;
}
ex_music[o++] = music[n];
} /*- FOR -*/
ex_music[o] = '\0';
strcpy(tmp, music);
strcpy(music, ex_music);
strcpy(ex_music, tmp);
// process Score marks stage (fermatas, trills, etc.)
int NoteCnt = 0;
char place[6];
/*- keep only notes and marks -*/
strcpy(MarksOut, "");
for (n = 0, o = 0; n <= (int)strlen(music); n++) {
if (isupper(music[n]) || music[n] == '('
|| music[n] == 't' || music[n] == ')'
|| music[n] == '-' || music[n] == '=') {
temp[o++] = music[n];
}
}
temp[o] = '\0';
for (n = 0; n <= (int)strlen(temp); n++) {
if (isupper(temp[n])) {
++NoteCnt;
continue;
}
if (temp[n] == 't') {
if ((int)strlen(MarksOut) > 0) {
strcat(MarksOut, "/");
}
strcat(MarksOut, "TR ");
sprintf(place, "%d", NoteCnt);
strcat(MarksOut, place);
continue;
}
if (temp[n] == '(') {
if (temp[n + 1] == '-' || temp[n + 1] == '=') {
continue;
}
if (temp[n + 2] == ')') {
if ((int)strlen(MarksOut) > 0) {
strcat(MarksOut, "/");
}
strcat(MarksOut, "FE ");
sprintf(place, "%d", NoteCnt + 1);
strcat(MarksOut, place);
}
}
}
strcat(MarksOut, ";");
// end Score marks stage
// process Score beams stage
int beams_flag = 0;
cue_flag = 0;
NoteCnt = 0;
char CueBeamsOut[256];
beam_cnt = 0;
bar_cnt = 1;
strcpy(BeamsOut, "");
strcpy(CueBeamsOut, "");
for (n = 0, o = 0; n <= (int)strlen(music); n++) {
if (isupper(music[n]) || music[n] == '{'
|| music[n] == '/' || isdigit(music[n])
|| music[n] == '=' || music[n] == '}'
|| music[n] == 'r' || music[n] == 'q') {
temp[o++] = music[n];
}
}
temp[o] = '\0';
for (n = 0; n <= (int)strlen(temp); n++) {
if (isdigit(temp[n])) {
zrhythm = temp[n];
continue;
}
if (temp[n] == '/') {
if (beams_flag < 0) {
printf
("RISM %s (%s, measure %d): start beam symbol "
"\"{\" wanting\n", id, incipit_id,
bar_cnt);
err_cnt++;
/* Serr_flag = 1; *//* changed to accommodate 20th-cent. */
} /* December 1996 -- JBH */
else if (beams_flag > 0) {
printf("RISM %s (%s, measure %d): end beam "
"symbol \"}\" wanting\n", id,
incipit_id, bar_cnt);
err_cnt++;
/* Serr_flag - 1; */
}
if (temp[n + 1] == '/')
++n;
beams_flag = 0;
++bar_cnt;
continue;
if (temp[n] == 'q' && temp[n + 1] == 'q') {
cue_flag = 1;
if ((int)strlen(CueBeamsOut) > 0) {
strcat(CueBeamsOut, "/");
}
sprintf(place, "%d", NoteCnt + 1);
strcat(strcat(CueBeamsOut, place), " ");
beams_flag++;
beam_cnt++;
continue;
}
if (temp[n] == 'r') {
cue_flag = 0;
beams_flag--;
sprintf(place, "%d", NoteCnt);
strcat(CueBeamsOut, place);
continue;
}
if (isupper(temp[n])) {
++NoteCnt;
if (beams_flag > 0) {
if (zrhythm == '1' || zrhythm == '2'
|| zrhythm == '4' || zrhythm == '9'
|| zrhythm == '0') {
printf
("RISM %s (%s, measure %d): invalid rhythm "
"in beamed group\n", id, incipit_id,
bar_cnt);
Serr_flag = 1;
err_cnt++;
zrhythm = '8';
}
}
continue;
}
if (temp[n] == '=') {
int z;
for (z = 0; isdigit(temp[n + 1]); n++)
rests[z++] = temp[n + 1];
if (z > 0) {
rests[z] = '\0';
bar_cnt = ((bar_cnt - 1) + (atoi(rests)));
z = 0;
}
continue;
}
if (temp[n] == '{') {
if (cue_flag == 0) {
if ((int)strlen(BeamsOut) > 0) {
strcat(BeamsOut, "/");
}
sprintf(place, "%d", NoteCnt + 1);
strcat(strcat(BeamsOut, place), " ");
beams_flag++;
beam_cnt++;
continue;
} else {
continue;
}
}
if (temp[n] == '}') {
if (cue_flag == 0) {
sprintf(place, "%d", NoteCnt);
strcat(BeamsOut, place);
beams_flag--;
continue;
} else {
continue;
}
}
if (beams_flag > 0) {
printf
("RISM %s (%s): end beam symbol \"}\" wanting in "
"last measure\n", id, incipit_id);
err_cnt++;
// Serr_flag = 1; -- JBH98
} else if (beams_flag < 0) {
printf
("RISM %s (%s): start beam symbol \"{\" wanting in "
"last measure\n", id, incipit_id);
err_cnt++;
// Serr_flag = 1; --JBH98
}
if ((int)strlen(BeamsOut) > 0 && (int)strlen(CueBeamsOut) > 0) {
strcat(BeamsOut, "/");
}
strcat(strcat(BeamsOut, CueBeamsOut), ";");
// end Score beams stage
// process Score slurs stage (ties & tuplets)
int n, o, NoteCnt = 0, f_flag = 0, r_flag = 0;
char place[6], temp[562], StartTuplet[6],
EndTuplet[6], TupletType[3];
strcpy(SlursOut, "");
for (n = 0, o = 0; n <= (int)strlen(music); n++) {
if (isdigit(music[n]) || isupper(music[n]) ||
music[n] == '+' || music[n] == '('
|| music[n] == '-' || music[n] == ')'
|| music[n] == ';' || music[n] == '=') {
temp[o++] = music[n];
}
}
temp[o] = '\0';
// process ties
for (n = 0; n <= (int)strlen(temp); n++) {
if (isupper(temp[n])) {
++NoteCnt;
continue;
}
if (temp[n] == '+') { // a tie
if (strlen(SlursOut) > 0) {
strcat(SlursOut, "/");
}
sprintf(place, "%d", NoteCnt);
strcat(strcat(SlursOut, place), " ");
if (n + 1 == (int)strlen(temp) || n == (int)strlen(temp)) {
strcat(strcat(SlursOut, place), ".99");
} else {
sprintf(place, "%d", NoteCnt + 1);
strcat(SlursOut, place);
}
}
}
// process tuplets
NoteCnt = 0;
for (n = 0; n <= (int)strlen(temp); n++) {
if (isupper(temp[n])) {
++NoteCnt;
continue;
}
if (temp[n] == '(') {
if (temp[n + 2] == ')' || temp[n + 1] == '=') {
f_flag = 1;
continue;
}
if (temp[n + 1] == '-' || (isdigit(temp[n + 1]) && temp[n + 2] == '-')
|| (isdigit(temp[n + 1]) && temp[n + 2] == '.'
&& temp[n + 3] == '-')) {
r_flag = 1;
}
if (r_flag == 0) {
sprintf(StartTuplet, "%d", NoteCnt + 1);
} else {
const char *fraction = ".9";
/*- JBH: 2 Jan 96, was ".8" -*/
printf ("RISM %s: tuplet figure begins with a rest !!\n", id);
sprintf(StartTuplet, "%d%s", NoteCnt - 1, fraction);
r_flag = 0;
}
continue;
}
if (temp[n] == ';') {
/*- tuplet type -*/
TupletType[0] = temp[n + 1];
TupletType[1] = '\0';
}
if (temp[n] == ')') {
if (f_flag == 1) {
f_flag = 0;
continue;
}
sprintf(EndTuplet, "%d", NoteCnt);
// write the output
if ((int)strlen(SlursOut) > 0) {
strcat(SlursOut, "/");
}
if ((int)strlen(TupletType) == 0) {
strcat(SlursOut, "3");
} else {
strcat(SlursOut, TupletType);
strcpy(TupletType, "");
}
if (atoi(StartTuplet) < 10) {
strcat(SlursOut, "0");
}
strcat(SlursOut, StartTuplet);
if (r_flag == 1) {
strcat(SlursOut, ".8");
}
strcat(SlursOut, " ");
strcat(strcat(SlursOut, "+"), EndTuplet);
r_flag = 0;
}
}
strcat(SlursOut, ";");
// end Score slurs stage
// determine width of musical notation on staff
for (n = 0, o = 0; n <= (int)strlen(music); n++) {
if (isupper(music[n])) {
tmp[o++] = music[n];
}
}
tmp[o] = '\0';
n = strlen(tmp);
if (n > 24) strcpy(inclen, "195");
else if (n > 22) strcpy(inclen, "185");
else if (n > 20) strcpy(inclen, "175");
else if (n > 17) strcpy(inclen, "160");
else if (n > 15) strcpy(inclen, "150");
else if (n > 13) strcpy(inclen, "140");
else if (n > 10) strcpy(inclen, "130");
else if (n > 7) strcpy(inclen, "120");
else if (n > 5) strcpy(inclen, "110");
else strcpy(inclen, "100");
TotalErrors = (TotalErrors + err_cnt);
if (err_cnt > 0 || Serr_flag == 1)
++TotalErrorRecords;
if (Serr_flag == 1) {
printf("- processing aborted\n");
Serr_flag = 0;
goto vinit;
}
if (rism == 0) {
strcpy(FileName, id);
if (incno < 100) /*- August 1996: allow for > 99 incipits */
sprintf(tmp, "%.2d", incno);
else
sprintf(tmp, "%.3d", incno);
strcat(FileName, tmp);
rstr(FileName, 5);
strcpy(subdir, library);
} else { /*- data from Zentralredaktion -*/
strcpy(tmp, id);
lstr(tmp, 3);
strcat(strcpy(subdir, library), "\\");
strcat(subdir, tmp);
strcpy(tmp, id);
rstr(tmp, 3);
strcpy(FileName, tmp);
if (incno < 100)
sprintf(tmp, "%.2d", incno);
else
sprintf(tmp, "%.3d", incno);
strcat(FileName, tmp);
}
if (proof == 0) {
output << "-- RISM " << id << " (" << incipit_id
<< ") -----------------------------------------\n";
output << "-> [clef:] " << ur_clef
<< "\t [key signature:] " << ur_keysig
<< "\t [time signature:] " << ur_timesig << "\n";
output << "-> " << ur_music << "\n";
output << "IN 1\n";
output << "1.5 " << inclen << " 1\n";
output << MusicOut << "\n";
output << RhythmOut << "\n";
output << MarksOut << "\n";
output << BeamsOut << "\n";
output << SlursOut << "\n";
if (beam_flag == 1) { // add score info to thin beams
int u = 0;
output << "ST 1 6\n";
for (; u < beam_cnt; u++) output << "17/.8\n\n";
output << "\n";
}
if (tclef_flag == 1) { // make the vocal tenor clef
output << "ST 1 3\n5/.8\n\n";
tclef_flag = 0;
}
if (format > 0) {
/* August 1996: get rid of CW1 in output */
output << "J\n1\n\n\nCW1\nSTM\nZ\n";
output << "CD \\" << country << "\\" << subdir << "\n";
output << "SA " << FileName << "\n";
if (print_flag == 0) {
output << "RS\nY\n";
}
} else {
output << "ST 1 8\n6/" << atoi(inclen)+2 << "\n";
output << "\nJ\n1\n\n\nCW1\nSTM\nZ\n";
output << "CD \\rism\\" << country << "\\" << subdir << "\n";
output << "SA " << FileName << "\n";
if (print_flag == 0) {
output << "RS\nY\n";
}
}
if (print_flag == 1) {
if (rism == 0) output << "CD \\RISM\\temp\nPR\n";
else output << "PR\n";
if (format == 0) {
output << ".42\n";
} else if (format == 1) {
output << ".65\n";
} else {
output << ".5\n";
}
output << "\n\n1 -2\nP\n" << FileName << "\nRS\nY\n";
}
}
// end of "if (proof == 0)" block
// reset varibles
vinit:
m_flag = 0;
strcpy(instrumentation, "");
strcpy(role, "");
strcpy(tempo, "");
strcpy(text, "");
strcpy(clef, "");
strcpy(timesig, "");
strcpy(music, "");
strcpy(comment, "");
strcpy(keysig, "");
strcpy(stitle, "");
strcpy(start_keysig, "");
strcpy(ur_keysig, "");
strcpy(value, "");
// end processing of incipits
// re-initialize selected variables
startpos = 0;
err_cnt = 0;
printf("==========================================================================\n");
printf("\n **** Statistics for RMUSIC processing run ****\n\n");
printf("\tRecords processed:\t%d\n", TotalRecords);
printf("\tIncipits processed:\t%d\n", TotalIncipits);
printf("\tErrors detected:\t%d in %d records\n", TotalErrors,
TotalErrorRecords);
return the data string here
}
////////////////////////////////////////////////////////////////////////////
//////////////////////////////
//
// spires2rism --
//
void spires2rism(FILE * ifp, FILE * ofp) {
int c, q_flag = 0, s_flag = 0;
int i = 0;
int rc = 0;
while ((c = getc(ifp)) != EOF) {
if (c == ' ') {
if (s_flag == 0) {
continue;
} else {
putc(' ', ofp);
while ((c = getc(ifp)) == ' ') {
;
}
}
}
if (c == '\"') {
if (q_flag == 1) {
if ((c = getc(ifp)) == '\"') {
putc(c, ofp);
s_flag = 1;
} else {
q_flag = 0;
s_flag = 0;
putc('\n', ofp);
(c = getc(ifp));
}
} else {
q_flag = 1;
s_flag = 1;
}
continue;
}
if (c == ';') {
if (q_flag == 1) {
putc(c, ofp);
s_flag = 1;
} else {
putc('\n', ofp);
s_flag = 0;
(c = getc(ifp));
}
continue;
}
if (c == '\n') {
putc(' ', ofp);
continue;
}
putc(c, ofp);
s_flag = 1;
}
}
//////////////////////////////
//
// MakeOctave --
//
void MakeOctave(char *s) {
char *octavein[] = {
"\'", "\'\'", "\'\'\'", "\'\'\'\'", "\'\'\'\'\'",
",", ",,", ",,,", ",,,,"
};
char *octaveout[] = {
"4", "5", "6", "7", "8",
"3", "2", "1", "0"
};
extern char id[];
int i;
for (i = 0; i <= 8; i++) {
if (strcmp(s, octavein[i]) == 0) {
strcpy(s, octaveout[i]);
return;
}
}
printf("RISM %s: strange octave register symbol -> %s\n", id, s);
return;
}
//////////////////////////////
//
// MakeRhythm --
//
void MakeRhythm(char *s) {
char *rhythmin[] = {
"1", "2", "4", "8", "6", "3", "5", "7", "9", "0"
};
char *rhythmout[] = {
"W", "H", "Q", "E", "S", "32", "64", "128", "DW", ".25"
};
extern char id[];
int i;
for (i = 0; i <= 9; i++) {
if (strcmp(s, rhythmin[i]) == 0) {
strcpy(s, rhythmout[i]);
return;
}
}
return;
}
//////////////////////////////
//
// MakeKeySignature --
//
int MakeKeySignature(char *s) {
char *keyin[] = {
"bB", "bBE", "bBEA", "bBEAD", "bBEADG", "bBEADGC", "bBEADGCF",
"xF", "xFC", "xFCG", "xFCGD", "xFCGDA", "xFCGDAE", "xFCGDAEB"
};
char *keyout[] = {
"/K1F", "/K2F", "/K3F", "/K4F", "/K5F", "/K6F", "/K7F",
"/K1S", "/K2S", "/K3S", "/K4S", "/K5S", "/K6S", "/K7S"
};
int i, o;
extern char id[];
char tmp[12];
/*- eliminate brackets and ampersand -*/
for (i = 0, o = 0; i <= (int)strlen(s); i++) {
if (s[i] == '[' || s[i] == ']' || s[i] == '&') {
continue;
}
tmp[o++] = s[i];
}
tmp[o] = '\0';
strcpy(s, tmp);
if (tmp[0] == 'n') { /* make natural signs */
strcpy(s, "");
return;
}
for (i = 0; i <= 14; i++) {
if (strcmp(s, keyin[i]) == 0) {
strcpy(s, keyout[i]);
return 1;
}
}
return -1;
}
//////////////////////////////
//
// MakeClef --
//
int MakeClef(char *s) {
char *clefin[] = {
"G-2", "C-1", "F-4", "C-3", "C-4", "G-1", "F-3", "F-2",
"C-2", "C-5", "G-3"
};
char *clefout[] = {
"TR", "TR", "BA", "AL", "TE", "TR", "BA", "BA",
"TR", "BA", "TE"
};
int i, o;
extern char id[];
extern int tclef_flag;
char tmp[12];
// eliminate brackets
for (i = 0, o = 0; i <= (int)strlen(s); i++) {
if (s[i] == '[' || s[i] == ']') {
continue;
}
tmp[o++] = s[i];
}
tmp[o] = '\0';
strcpy(s, tmp);
if (s[0] == 'g') { // vocal tenor clef
tclef_flag = 1;
strcpy(s, "G-2");
}
if (s[1] == '+') { // mensural notation
s[1] = '-';
if (s[2] == '5')
s[2] = '4';
if (verbose == 1) {
printf("RISM %s: mensural notation is called for!\n", id);
}
}
for (i = 0; i <= 10; i++) {
if (strcmp(s, clefin[i]) == 0) {
strcpy(s, clefout[i]);
return 1;
}
}
return -1;
}
//////////////////////////////
//
// MakeTimeSignature --
//
int MakeTimeSignature(char *s) {
char *timein[] = {
"c", "c/", "o", "o/", "&C", "&alla;",
"3/1", "2/1", "4/1", "6/1", "8/1", "2/2", "3/2", "4/2",
"6/2", "8/2", "2/4", "3/4", "4/4", "5/4", "6/4",
"7/4", "8/4", "9/4", "10/4", "2/8", "3/8", "4/8",
"5/8", "6/8", "8/8", "9/8", "12/8", "16/8", "8/16",
"6/16", "9/16", "12/16", "16/16", "20/4", "20/16", "24/16",
"12/4", "1/4", "10/2", "c3/2", "c3", "c/3",
"38/4", "c2", "c/2", "1/2", "3", "2", "4", "1", "0",
"c/3/1", "c/3/2", "c/6/4", "c6/4", ""
};
char *timeout[] = {
"/COM", "/CUT", "/3 1", "/3 2", "/COM", "/CUT",
"/3 1", "/2 1", "/4 1", "/6 1", "/8 1", "/2 2", "/3 2", "/4 2",
"/6 2", "/8 2", "/2 4", "/3 4", "/4 4", "/5 4", "/6 4",
"/7 4", "/8 4", "/9 4", "/10 4", "/2 8", "/3 8", "/4 8",
"/5 8", "/6 8", "/8 8", "/9 8", "/12 8", "/16 8", "/8 16",
"/6 16", "/9 16", "/12 16", "/16 16", "/20 4", "/20 16", "/24 16",
"/12 4", "/1 4", "/10 2", "/COM/3 2", "/COM/3", "/COM/3",
"/38 4", "/COM/2", "/COM/2", "/1 2", "/3", "/2", "/4", "/1", "",
"/COM/3 1", "/COM/3 2", "/COM/6 4", "/COM/6 4", ""
};
int i, o;
extern char id[];
char tmp[12];
/*- eliminate brackets -*/
for (i = 0, o = 0; i <= (int)strlen(s); i++) {
if (s[i] == '[' || s[i] == ']') {
continue;
}
tmp[o++] = s[i];
}
tmp[o] = '\0';
strcpy(s, tmp);
for (i = 0; i <= 61; i++) {
if (strcmp(s, timein[i]) == 0) {
strcpy(s, timeout[i]);
return 1;
}
}
/*- try to catch other time sigs -*/
printf("RISM %s (%s): unusual time signature \"%s\"\n", id, incipit_id,
s);
for (i = 0; i <= (int)strlen(s); i++) {
if (s[i] == '/')
tmp[i] = ' ';
else
tmp[i] = s[i];
}
tmp[o] = '\0';
strcpy(s, "/");
strcat(s, tmp);
return;
/*- assuming nothing gets past here, the following not necessary -*/
return -1;
}
//////////////////////////////
//
// lstr --
//
void lstr(char *s, int n) {
int i;
char tmp[2056];
for (i = 0; i < n; i++)
tmp[i] = s[i];
tmp[i] = '\0';
strcpy(s, tmp);
return;
}
//////////////////////////////
//
// rstr --
//
void rstr(char *s, int n) {
int i, o = 0;
char tmp[2056];
for (i = 0; i <= (int)strlen(s); i++) {
if (i >= n)
tmp[o++] = s[i];
}
tmp[o] = '\0';
strcpy(s, tmp);
return;
}
//////////////////////////////
//
// readline -- read a line of text from the input file
// simulating the fgets function but better behaved
// at the end of a file where there is no newline.
//
int readline(char * storage, int max, FILE* fr) {
int i;
int inchar;
for (i=0; i<max-2; i++) {
inchar = fgetc(fr);
if (inchar == EOF) {
if (i == 0) {
}
break;
} else {
storage[i] = (char)inchar;
}
if (storage[i] == '\n') {
break;
}
}
if (i==0 && inchar == EOF) {
return 0;
}
if (storage[i-1] != '\n') {
storage[i] = '\n';
i++;
}
storage[i] = '\0';
return 1;
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
//////////////////////////////
//
// usage -- gives the usage statement for the program
//
void usage(const char* command) {
cout << " " << endl;
// original usage statement
// if (a == 0) {
// printf("rmusic: prepare input file for Score music typesetting "
// "program from RISM A/II SPIRES standard format\n\n");
// printf("Input file not specified\nUsage: rmusic "
// "fn_in {fn_out} -lMpr\n");
// printf("\n -p = prepare EPS printing instructions\n");
// printf(" -l = print with long staves (for WWW site)\n");
// printf(" -M = omit music input files (use with -p)\n");
// printf(" -r = Score output will be written to \\rism\\temp\n");
// printf(" -P = output proofreading information only\n");
// printf(" -R = source file is from RISM Zentralredaktion\n");
// printf
// (" -s = Score output file prints with size factor of .5\n");
// printf(" -b = Score output thins beams by factor of .8\n");
// return;
}
//////////////////////////////
//
// checkOptions -- validate and process command-line options.
//
void checkOptions(Options& opts, int argc, char* argv[]) {
// original options:
// p => print_flag = 1;
// M => music_flat = 1;
// l => format = 1;
// r => directory = 1;
// R => rism = 1;
// s => format = 2;
// p => proof = 1;
// b => beam_flat = 1; set beam thickness to 0.8 (thin) in SCORE.
// v => verbose = 1;
opts.define("debug=b"); // determine bad input line num
opts.define("author=b"); // author of program
opts.define("version=b"); // compilation info
opts.define("example=b"); // example usages
opts.define("h|help=b"); // short description
opts.process(argc, argv);
// handle basic options:
if (opts.getBoolean("author")) {
cout << "Written by Craig Stuart Sapp, "
<< "craig@ccrma.stanford.edu, August 2006" << endl;
exit(0);
} else if (opts.getBoolean("version")) {
cout << argv[0] << ", version: 15 August 2006" << endl;
cout << "compiled: " << __DATE__ << endl;
exit(0);
} else if (opts.getBoolean("help")) {
usage(opts.getCommand());
exit(0);
} else if (opts.getBoolean("example")) {
example();
exit(0);
}
}
//////////////////////////////
//
// example -- example usage of the program
//
void example(void) {
cout << " " << endl;
}
// md5sum: 1281b5755490cb9b169487a9cb440f43 pe2score.cpp [20110711]