diff --git a/.gitignore b/.gitignore index 24c48db..cacc9aa 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ /Java/MoppyDesk/nbproject/private/ /Java/MoppyDesk/build/ -/Java/MoppyDesk/dist/ \ No newline at end of file +/Java/MoppyDesk/dist/ +midicomp +*.o diff --git a/tools/midicomp-0.0.4/Makefile b/tools/midicomp-0.0.4/Makefile new file mode 100644 index 0000000..6f609bd --- /dev/null +++ b/tools/midicomp-0.0.4/Makefile @@ -0,0 +1,30 @@ +# $Id: makefile.unx,v 1.3 1991/11/15 19:31:00 piet Rel $ + +CFLAGS = -O +# If you have an old version of flex that defines yyleng +# as a macro rather than a variable, uncomment the following line: +# CFLAGS = -O -DNO_YYLENG_VAR + +SRCS = midicomp.c t2mf.fl t2mflex.c yyread.c + +EXECS = midicomp + +all: $(EXECS) + +midicomp: midicomp.h midicomp.o t2mf.h t2mflex.o + $(CC) midicomp.o t2mflex.o -o midicomp + +t2mflex.c: t2mf.fl + flex -i -s -Ce t2mf.fl + mv lex.yy.c t2mflex.c + +t2mflex.o: t2mflex.c t2mf.h + +clean: + rm -f *.o midicomp + +install: + cp midicomp /usr/bin ; mv midicomp midicom.exe + +dist: + tar czf midicomp-$$(cat VERSION).tar.gz ./ --exclude=*.html --exclude=*.tar.gz diff --git a/tools/midicomp-0.0.4/Readme b/tools/midicomp-0.0.4/Readme new file mode 100644 index 0000000..bf94d26 --- /dev/null +++ b/tools/midicomp-0.0.4/Readme @@ -0,0 +1,177 @@ +midicomp v0.0.2 20070722 markc@renta.net + +A program to manipulate SMF (Standard MIDI File) files. midicomp will +both read and write SMF files in 0 or format 1 and also read and write +it's own plain text format. This means a SMF file can be turned into +easily parseble text, edited with any text editor or filtered through +any script language, and "recompiled" back into a binary SMF file. + +Originally based on mf2t/t2fm by Piet van Oostrum and others. It should +build on any linux simply by typing "make" in the source directory. + +Changes: + +v0.0.2 20070722 Fixed gcc4+ compiler bug and exit warnings +v0.0.1 20031129 Initial release, combined mf2t+t2fm, added getopt args + +Command line argument usage: + + -d --debug send any debug output to stderr + -v --verbose output in columns with notes on + -c --compile compile ascii input into SMF + -n --note note on/off value as note|octave + -t --time use absolute time instead of ticks + -fN --fold=N fold sysex data at N columns + +To translate a SMF file to plain ascii format: + + midicomp some.mid # to view as plain text + midicomp some.mid > some.asc # to create a text version + +To translate a plain ascii formatted file to SMF: + + midicomp -c some.asc some.mid # input and output filenames + midicomp -c some.mid < some.asc # input from stdin with one arg + + midicomp some.mid | somefilter | midicomp -c some2.mid + +Format of the textfile: + +File header: Mfile +Start of track: MTrk +End of track: TrkEnd + +Note On: On +Note Off: Off +Poly Pressure: PoPr[PolyPr] +Channel Pressure: ChPr[ChanPr] +Controller parameter: Par[Param] +Pitch bend: Pb +Program change: PrCh[ProgCh] +Sysex message: SysEx +Arbutrary midi bytes: Arb + +Sequence nr: Seqnr +Key signature: KeySig +Tempo: Tempo +Time signature: TimeSig / +SMPTE event: SMPTE + +Meta text events: Meta +Meta end of track: Meta TrkEnd +Sequencer specific: SeqSpec +Misc meta events: Meta + +The <> have the following meaning: + + ch= + n= [note=] + v= [vol=] + v= [val=] + c= [con=] + p= [prog=] + minor or major + either a or A-G optionally followed by #, + followed by without intermediate spaces. + Text Copyright SeqName TrkName InstrName Lyric Marker Cue + a hex number of the form 0xab + a sequence of 2-digit hex numbers (without 0x) + separated by space + a string between double quotes (like "text"). + +Misc notes: + +Channel numbers are 1-based, all other numbers are as they appear in the +midifile. + + is either a positive number (giving the time resolution in +clicks per quarter note) or a negative number followed by a positive +number (giving SMPTE timing). + + are decimal numbers. + +The in the Pb is the real value (two midibytes combined) + +In Tempo it is a long (32 bits) value. Others are in the interval 0-127 + +The SysEx sequence contains the leading F0 and the trailing F7. + +In a string certain characters are escaped: + +" and \ are escaped with a \ +a zero byte is written as \0 +CR and LF are written as \r and \n respectively +other non-printable characters are written as \x<2 hex digits> +When -f is given long strings and long hex sequences are folded by inserting +\. If in a string the next character would be a space or +tab it will be escaped by \ + +midicomp will accept all formats that mf2t can produce, plus a number of +others. Input is case insensitive (except in strings) and extra tabs and +spaces are allowed. Newlines are required but empty lines are allowed. +Comment starts with # at the beginning of a lexical item and continues +to the end of the line. The only other places where a # is legal are +insides strings and as a sharp symbol in a symbolic note. + +In symbolic notes + and # are allowed for sharp, b and - for flat. + +In bar:beat:click time the : may also be / + +On input a string may also contain \t for a tab, and in a folded +string any whitespace at the beginning of a continuation line is skipped. + +Hex sequences may be input without intervening spaces if each byte is +given as exactly 2 hex digits. + +Hex sequences may be given where a string is required and vice versa. + +Hex numbers of the form 0xaaa and decimal numbers are equivalent. +Also allowed as numbers are "bank numbers" of the form '123. In fact +this is equivalent to the octal number 012 (subtract 1 from each +digit, digits 1-8 allowed). The letters a-h may also be used for 1-8. + +The input is checked for correctness but not extensively. An +errormessage will generally imply that the resulting midifile is illegal. + +channel number can be recognized by the regular expression /ch=/. +note numbers by /n=/ or /note=/, program numbers by /p=/ or /prog=/. +Meta events by /^Meta/ or /^SeqSpec/. +Text events by /"/, continued lines by /\\$/, continuation lines by /$\t/ +(that was a TAB character). + +In awk each parameter is a field, in perl you can use split to get the +parameters (except for strings). + +The following perl script changes note off messages to note on with +vol=0, deletes controller 3 changes, makes some note reassignments on +channel 10, and changes the channel numbers from channel 1 depending +on the track number. + +------------------------------- test.pl ------------------------------- +%drum = (62, 36, 63, 47, 65, 61, 67, 40, 68, 54); + +while (<>) { + next if /c=3/; + s/Off(.*)v=[0-9]*/On\1v=0/; + if (/ch=10/ && /n=([0-9]*)/ && $drum{$1}) { + s/n=$1/"n=".$drum{$1}/e; + } + if (/^MTrk/) {++$trknr ; print "track $trknr\n";} + if ($trknr > 2) { s/ch=1\b/ch=3/; } + else { s/ch=1\b/ch=4/; } + print || die "Error: $!\n"; +} +------------------------------------------------------------------------ + +and this is the corresponding awk script. + +------------------------------- test.awk ------------------------------- +BEGIN { drum[62] = 36; drum[63] = 47; drum[65] = 61; \ + drum[67] = 40; drum[68] = 54 } +/c=3/ { next } +($2 == "Off") { $2 = "On"; $5 = "v=0" } +/ch=10/ { n = substr($4, 3); if (n in drum) $4 = "n=" drum[n] } +/^MTrk/ { trknr++ } +/ch=1 / { if (trknr > 2) { $3 = "ch=2" } else { $3 = "ch=3" } } +{ print } +------------------------------------------------------------------------ diff --git a/tools/midicomp-0.0.4/VERSION b/tools/midicomp-0.0.4/VERSION new file mode 100644 index 0000000..4e379d2 --- /dev/null +++ b/tools/midicomp-0.0.4/VERSION @@ -0,0 +1 @@ +0.0.2 diff --git a/tools/midicomp-0.0.4/ex1-plain.txt b/tools/midicomp-0.0.4/ex1-plain.txt new file mode 100644 index 0000000..9481a33 --- /dev/null +++ b/tools/midicomp-0.0.4/ex1-plain.txt @@ -0,0 +1,39 @@ +MFile 1 1 384 +MTrk +0 Meta SeqName "Track 1" +0 On ch=1 n=48 v=70 +0 Tempo 500000 +0 TimeSig 4/4 32 99 +96 On ch=1 n=48 v=0 +96 On ch=1 n=50 v=70 +192 On ch=1 n=50 v=0 +192 On ch=1 n=52 v=70 +288 On ch=1 n=52 v=0 +288 On ch=1 n=53 v=70 +384 On ch=1 n=53 v=0 +384 On ch=1 n=55 v=70 +480 On ch=1 n=55 v=0 +480 On ch=1 n=57 v=70 +576 On ch=1 n=57 v=0 +576 On ch=1 n=59 v=70 +672 On ch=1 n=59 v=0 +672 On ch=1 n=60 v=70 +768 On ch=1 n=60 v=0 +768 On ch=1 n=62 v=70 +864 On ch=1 n=62 v=0 +864 On ch=1 n=60 v=70 +960 On ch=1 n=60 v=0 +960 On ch=1 n=59 v=70 +1056 On ch=1 n=59 v=0 +1056 On ch=1 n=57 v=70 +1152 On ch=1 n=57 v=0 +1152 On ch=1 n=55 v=70 +1248 On ch=1 n=55 v=0 +1248 On ch=1 n=53 v=70 +1344 On ch=1 n=53 v=0 +1344 On ch=1 n=52 v=70 +1440 On ch=1 n=52 v=0 +1440 On ch=1 n=50 v=70 +1536 On ch=1 n=50 v=0 +1536 Meta TrkEnd +TrkEnd diff --git a/tools/midicomp-0.0.4/ex1-verbose.txt b/tools/midicomp-0.0.4/ex1-verbose.txt new file mode 100644 index 0000000..e98cdc5 --- /dev/null +++ b/tools/midicomp-0.0.4/ex1-verbose.txt @@ -0,0 +1,39 @@ +MFile 1 1 384 +MTrk +000:00:000 Meta SeqName "Track 1" +000:00:000 On ch=1 note=c4 vol=70 +000:00:000 Tempo 500000 +000:00:000 TimeSig 4/4 32 99 +000:00:096 On ch=1 note=c4 vol=0 +000:00:096 On ch=1 note=d4 vol=70 +000:00:192 On ch=1 note=d4 vol=0 +000:00:192 On ch=1 note=e4 vol=70 +000:00:288 On ch=1 note=e4 vol=0 +000:00:288 On ch=1 note=f4 vol=70 +000:01:000 On ch=1 note=f4 vol=0 +000:01:000 On ch=1 note=g4 vol=70 +000:01:096 On ch=1 note=g4 vol=0 +000:01:096 On ch=1 note=a4 vol=70 +000:01:192 On ch=1 note=a4 vol=0 +000:01:192 On ch=1 note=b4 vol=70 +000:01:288 On ch=1 note=b4 vol=0 +000:01:288 On ch=1 note=c5 vol=70 +000:02:000 On ch=1 note=c5 vol=0 +000:02:000 On ch=1 note=d5 vol=70 +000:02:096 On ch=1 note=d5 vol=0 +000:02:096 On ch=1 note=c5 vol=70 +000:02:192 On ch=1 note=c5 vol=0 +000:02:192 On ch=1 note=b4 vol=70 +000:02:288 On ch=1 note=b4 vol=0 +000:02:288 On ch=1 note=a4 vol=70 +000:03:000 On ch=1 note=a4 vol=0 +000:03:000 On ch=1 note=g4 vol=70 +000:03:096 On ch=1 note=g4 vol=0 +000:03:096 On ch=1 note=f4 vol=70 +000:03:192 On ch=1 note=f4 vol=0 +000:03:192 On ch=1 note=e4 vol=70 +000:03:288 On ch=1 note=e4 vol=0 +000:03:288 On ch=1 note=d4 vol=70 +001:00:000 On ch=1 note=d4 vol=0 +001:00:000 Meta TrkEnd +TrkEnd diff --git a/tools/midicomp-0.0.4/ex1.mid b/tools/midicomp-0.0.4/ex1.mid new file mode 100644 index 0000000..62b73b7 Binary files /dev/null and b/tools/midicomp-0.0.4/ex1.mid differ diff --git a/tools/midicomp-0.0.4/midicomp.c b/tools/midicomp-0.0.4/midicomp.c new file mode 100644 index 0000000..d21e465 --- /dev/null +++ b/tools/midicomp-0.0.4/midicomp.c @@ -0,0 +1,1350 @@ +/* +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., +59 Temple Place, Suite 330, Boston, +MA 02111-1307 USA +*/ + +char *usage = "\n\ +midicomp v0.0.1 20031129 markc@renta.net \n\ + \n\ +http://alsa.opensrc.org/midicomp/ \n\ + \n\ +Command line argument usage: \n\ + \n\ + -d --debug send any debug output to stderr \n\ + -v --verbose output in columns with notes on \n\ + -c --compile compile ascii input into SMF \n\ + -n --note note on/off value as note|octave \n\ + -t --time use absolute time instead of ticks \n\ + -fN --fold=N fold sysex data at N columns \n\ + \n\ +To translate a SMF file to plain ascii format: \n\ + \n\ + midicomp some.mid # to view as plain text \n\ + midicomp some.mid > some.asc # to create a text version \n\ + \n\ +To translate a plain ascii formatted file to SMF: \n\ + \n\ + midicomp -c some.asc some.mid # input and output filenames \n\ + midicomp -c some.mid < some.asc # input from stdin with one arg \n\ + \n\ + midicomp some.mid | somefilter | midicomp -c some2.mid \n"; + +#include +#include +#include +#include +#include +#include +#include +#include +#include "midicomp.h" + +int main(int argc,char **argv) { + + FILE *efopen(); + Mf_nomerge = 1; + opterr = 0; + int compile = 0; + int c; + + struct option long_options[] = { + {"debug", no_argument, 0, 'd'}, + {"verbose", no_argument, 0, 'v'}, + {"compile", no_argument, 0, 'c'}, + {"note", no_argument, 0, 'n'}, + {"time", no_argument, 0, 't'}, + {"fold", required_argument, 0, 'f'}, + {0, 0, 0, 0} + }; + int option_index = 0; + + while ((c = getopt_long(argc,argv,"dvcntf:",long_options,&option_index)) != -1) { + switch (c) { + case 0: + if (long_options[option_index].flag != 0) + break; + case 'd': + dbg++; + break; + case 'f': + fold = atoi(optarg); + fprintf(stderr,"fold=%d\n",fold); + break; + case 'm': + Mf_nomerge = 0; + break; + case 'n': + notes++; + break; + case 't': + times++; + break; + case 'c': + compile++; + break; + case 'v': + verbose++; + notes++; + break; + case 'h': + default: + fprintf(stderr,"%s\n",usage); + return 1; + } + } +if (dbg) fprintf(stderr,"main()\n"); + + TrkNr = 0; + Measure = 4; + Beat = 96; + Clicks = 96; + M0 = 0; + T0 = 0; + + if (compile) { + char *infile; + char *outfile; + + if (optind < argc) { + yyin = efopen (argv[optind], "r"); + infile = argv[optind]; + } else { + yyin = stdin; + infile = "stdin"; + } + if (optind+1 < argc ) { + F = efopen(argv[optind+1],"wb"); + outfile = argv[optind+1]; + } else { +#ifdef SETMODE + setmode (fileno(stdout), O_BINARY); + F = stdout; +#else + F = fdopen (fileno(stdout), "wb"); +#endif + outfile = "stdout"; + } +if (dbg) fprintf(stderr,"Compiling %s to %s\n",infile,outfile); + + Mf_putc = fileputc; + Mf_wtrack = mywritetrack; + translate(); + fclose(F); + fclose(yyin); + } else { + if (verbose) { + Onmsg = "On ch=%-2d note=%-3s vol=%-3d\n"; + Offmsg = "Off ch=%-2d note=%-3s vol=%-3d\n"; + PoPrmsg = "PolyPr ch=%-2d note=%-3s val=%-3d\n"; + Parmsg = "Param ch=%-2d con=%-3d val=%-3d\n"; + Pbmsg = "Pb ch=%-2d val=%-3d\n"; + PrChmsg = "ProgCh ch=%-2d prog=%-3d\n"; + ChPrmsg = "ChanPr ch=%-2d val=%-3d\n"; + } + if (optind < argc) + F = efopen(argv[optind],"rb"); + else + F = fdopen(fileno(stdin),"rb"); + + initfuncs(); + Mf_getc = filegetc; + mfread(); + if (ferror(F)) error ("Output file error"); + fclose(F); + } +} + +mfread() { + + if (Mf_getc == NULLFUNC) + mferror("mfread() called without setting Mf_getc"); + + readheader(); + while(readtrack()) ; +} + +static readmt(char *s) { + + int n = 0; + char *p = s; + int c; + + while ( n++<4 && (c=(*Mf_getc)()) != EOF ) { + if ( c != *p++ ) { + char buff[32]; + (void) strcpy(buff,"expecting "); + (void) strcat(buff,s); + mferror(buff); + } + } + return(c); +} + +static egetc() { + + int c = (*Mf_getc)(); + + if ( c == EOF ) + mferror("premature EOF"); + Mf_toberead--; + return(c); +} + +static void readheader() { + + int format, ntrks, division; + + if (readmt("MThd") == EOF) return; + Mf_toberead = read32bit(); + format = read16bit(); + ntrks = read16bit(); + division = read16bit(); + if (Mf_header) (*Mf_header)(format,ntrks,division); + while(Mf_toberead > 0) (void) egetc(); +} + +static readtrack() { + + long lookfor; + int c, c1, type; + int sysexcontinue = 0; + int running = 0; + int status = 0; + int needed; + static int chantype[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 1, 1, 2, 0 + }; + + if (readmt("MTrk") == EOF) return(0); + Mf_toberead = read32bit(); + Mf_currtime = 0; + if (Mf_starttrack) (*Mf_starttrack)(); + + while (Mf_toberead > 0) { + Mf_currtime += readvarinum(); + c = egetc(); + if (sysexcontinue && c != 0xf7) + mferror("didn't find expected continuation of a sysex"); + if ((c & 0x80) == 0) { + if (status == 0) mferror("unexpected running status"); + running = 1; + c1 = c; + c = status; + } else if (c < 0xf0) { + status = c; + running = 0; + } + needed = chantype[ (c>>4) & 0xf ]; + if (needed) { + if (!running) c1 = egetc(); + chanmessage(status,c1,(needed>1) ? egetc() : 0 ); + continue; + } + + switch(c) { + case 0xff: + type = egetc(); + lookfor = Mf_toberead - readvarinum(); + msginit(); + while(Mf_toberead >= lookfor) msgadd(egetc()); + metaevent(type); + break; + case 0xf0: + lookfor = Mf_toberead - readvarinum(); + msginit(); + msgadd(0xf0); + while(Mf_toberead > lookfor) msgadd(c=egetc()); + if (c == 0xf7 || Mf_nomerge == 0) + sysex(); + else + sysexcontinue = 1; + break; + case 0xf7: + lookfor = Mf_toberead - readvarinum(); + if (! sysexcontinue) msginit(); + while (Mf_toberead > lookfor) msgadd(c=egetc()); + if (! sysexcontinue) { + if (Mf_arbitrary) (*Mf_arbitrary)(msgleng(),msg()); + } else if (c == 0xf7) { + sysex(); + sysexcontinue = 0; + } + break; + default: + badbyte(c); + break; + } + } + if ( Mf_endtrack ) (*Mf_endtrack)(); + return(1); +} + +static badbyte(int c) { + + char buff[32]; + + (void) sprintf(buff,"unexpected byte: 0x%02x",c); + mferror(buff); +} + +static metaevent(type) { + + int leng = msgleng(); + char *m = msg(); + + switch (type) { + case 0x00: + if (Mf_seqnum) (*Mf_seqnum)(to16bit(m[0],m[1])); + break; + case 0x01: /* Text event */ + case 0x02: /* Copyright notice */ + case 0x03: /* Sequence/Track name */ + case 0x04: /* Instrument name */ + case 0x05: /* Lyric */ + case 0x06: /* Marker */ + case 0x07: /* Cue point */ + case 0x08: + case 0x09: + case 0x0a: + case 0x0b: + case 0x0c: + case 0x0d: + case 0x0e: + case 0x0f: + if (Mf_text) (*Mf_text)(type,leng,m); + break; + case 0x2f: + if (Mf_eot) (*Mf_eot)(); + break; + case 0x51: + if (Mf_tempo) (*Mf_tempo)(to32bit(0,m[0],m[1],m[2])); + break; + case 0x54: + if (Mf_smpte) + (*Mf_smpte)(m[0],m[1],m[2],m[3],m[4]); + break; + case 0x58: + if (Mf_timesig) + (*Mf_timesig)(m[0],m[1],m[2],m[3]); + break; + case 0x59: + if (Mf_keysig) (*Mf_keysig)(m[0],m[1]); + break; + case 0x7f: + if (Mf_sqspecific) (*Mf_sqspecific)(leng,m); + break; + default: + if (Mf_metamisc) (*Mf_metamisc)(type,leng,m); + } +} + +static sysex() { + + if (Mf_sysex) (*Mf_sysex)(msgleng(),msg()); +} + +static chanmessage(int status,int c1,int c2) { + + int chan = status & 0xf; + + switch(status & 0xf0) { + case 0x80: if (Mf_off) (*Mf_off)(chan,c1,c2); break; + case 0x90: if (Mf_on) (*Mf_on)(chan,c1,c2); break; + case 0xa0: if (Mf_pressure) (*Mf_pressure)(chan,c1,c2); break; + case 0xb0: if (Mf_parameter) (*Mf_parameter)(chan,c1,c2); break; + case 0xe0: if (Mf_pitchbend) (*Mf_pitchbend)(chan,c1,c2); break; + case 0xc0: if (Mf_program) (*Mf_program)(chan,c1); break; + case 0xd0: if (Mf_chanpressure) (*Mf_chanpressure)(chan,c1); break; + } +} + +static long readvarinum() { + + long value; + int c; + + c = egetc(); + value = c; + if (c & 0x80) { + value &= 0x7f; + do { + c = egetc(); + value = (value << 7) + (c & 0x7f); + } while (c & 0x80); + } + return (value); +} + +static long to32bit(c1,c2,c3,c4) { + + long value = 0L; + + value = (c1 & 0xff); + value = (value<<8) + (c2 & 0xff); + value = (value<<8) + (c3 & 0xff); + value = (value<<8) + (c4 & 0xff); + return (value); +} + +static to16bit(int c1,int c2) { + + return ((c1 & 0xff ) << 8) + (c2 & 0xff); +} + +static long read32bit() { + + int c1, c2, c3, c4; + + c1 = egetc(); + c2 = egetc(); + c3 = egetc(); + c4 = egetc(); + return to32bit(c1,c2,c3,c4); +} + +static read16bit() { + + int c1, c2; + c1 = egetc(); + c2 = egetc(); + return to16bit(c1,c2); +} + +mferror(char *s) { + + if (Mf_error) (*Mf_error)(s); + exit(1); +} + +static msginit() { + + Msgindex = 0; +} + +static char * msg() { + + return(Msgbuff); +} + +static msgleng() { + + return(Msgindex); +} + +static msgadd(int c) { + + if (Msgindex >= Msgsize) biggermsg(); + Msgbuff[Msgindex++] = c; +} + +static biggermsg() { + + char *newmess; + char *oldmess = Msgbuff; + int oldleng = Msgsize; + + Msgsize += MSGINCREMENT; + newmess = (char *) malloc((unsigned)(sizeof(char)*Msgsize)); + if (newmess == NULL) mferror("malloc error!"); + if (oldmess != NULL) { + register char *p = newmess; + register char *q = oldmess; + register char *endq = &oldmess[oldleng]; + for( ; q!=endq ; p++,q++ ) *p = *q; + free(oldmess); + } + Msgbuff = newmess; +} + +void mfwrite(int format,int ntracks,int division,FILE *fp) { + + int i; + void mf_w_track_chunk(),mf_w_header_chunk(); + + if (Mf_putc == NULLFUNC) + mferror("mfmf_write() called without setting Mf_putc"); + if (Mf_wtrack == NULLFUNC) + mferror("mfmf_write() called without setting Mf_mf_writetrack"); + mf_w_header_chunk(format,ntracks,division); + if (format == 1 && ( Mf_wtempotrack )) { + mf_w_track_chunk(-1,fp,Mf_wtempotrack); + ntracks--; + } + for(i = 0; i < ntracks; i++) + mf_w_track_chunk(i,fp,Mf_wtrack); +} + +void mf_w_track_chunk(which_track,fp,wtrack) +int which_track; +FILE *fp; +int (*wtrack)(); +{ + unsigned long trkhdr,trklength; + long offset, place_marker; + void write16bit(),write32bit(); + + trkhdr = MTrk; + trklength = 0; + + offset = ftell(fp); + write32bit(trkhdr); + write32bit(trklength); + + Mf_numbyteswritten = 0L; + laststat = 0; + (*wtrack)(which_track); + + if (laststat != meta_event || lastmeta != end_of_track) { + eputc(0); + eputc(meta_event); + eputc(end_of_track); + eputc(0); + } + + laststat = 0; + place_marker = ftell(fp); + if (fseek(fp,offset,0) < 0) + mferror("error seeking during final stage of write"); + trklength = Mf_numbyteswritten; + write32bit(trkhdr); + write32bit(trklength); + fseek(fp,place_marker,0); +} + +void mf_w_header_chunk(int format,int ntracks,int division) { + + unsigned long ident,length; + void write16bit(),write32bit(); + + ident = MThd; + length = 6; + write32bit(ident); + write32bit(length); + write16bit(format); + write16bit(ntracks); + write16bit(division); +} + +int mf_w_midi_event(unsigned long delta_time,unsigned int type, +unsigned int chan,unsigned char *data,unsigned long size) { + + int i; + unsigned char c; + + WriteVarLen(delta_time); + c = type | chan; + + if(chan > 15) + perror("error: MIDI channel greater than 16\n"); + if (!Mf_RunStat || laststat != c) + eputc(c); + laststat = c; + for(i = 0; i < size; i++) + eputc(data[i]); + + return(size); +} + +int mf_w_meta_event(unsigned long delta_time, +unsigned int type,unsigned char *data,unsigned long size) { + + int i; + + WriteVarLen(delta_time); + eputc(meta_event); + laststat = meta_event; + eputc(type); + lastmeta = type; + WriteVarLen(size); + for(i = 0; i < size; i++) { + if (eputc(data[i]) != data[i]) return(-1); + } + return(size); +} + +int mf_w_sysex_event(unsigned long delta_time, +unsigned char *data,unsigned long size) { + + int i; + + WriteVarLen(delta_time); + eputc(*data); + laststat = 0; + WriteVarLen(size-1); + for(i = 1; i < size; i++) { + if(eputc(data[i]) != data[i]) return(-1); + } + return(size); +} + +void mf_w_tempo(unsigned long delta_time,unsigned long tempo) { + + WriteVarLen(delta_time); + eputc(meta_event); + laststat = meta_event; + eputc(set_tempo); + eputc(3); + eputc((unsigned)(0xff & (tempo >> 16))); + eputc((unsigned)(0xff & (tempo >> 8))); + eputc((unsigned)(0xff & tempo)); +} + +unsigned long mf_sec2ticks(float secs,int division,unsigned int tempo) { + + return (long)(((secs * 1000.0) / 4.0 * division) / tempo); +} + +void WriteVarLen(unsigned long value) { + + unsigned long buffer; + + buffer = value & 0x7f; + while((value >>= 7) > 0) { + buffer <<= 8; + buffer |= 0x80; + buffer += (value & 0x7f); + } + while(1) { + eputc((unsigned)(buffer & 0xff)); + if (buffer & 0x80) + buffer >>= 8; + else + return; + } +} + +float mf_ticks2sec(int ticks,unsigned int division,unsigned long tempo) { + + float smpte_format,smpte_resolution; + + if (division > 0) { + return((float)(((float) (ticks)*(float)(tempo))/ + ((float)(division)*1000000.0))); + } else { + smpte_format = upperbyte(division); + smpte_resolution = lowerbyte(division); + return(float)((float) ticks/(smpte_format*smpte_resolution*1000000.0)); + } +} + +void write32bit(unsigned long data) { + + eputc((unsigned)((data >> 24) & 0xff)); + eputc((unsigned)((data >> 16) & 0xff)); + eputc((unsigned)((data >> 8 ) & 0xff)); + eputc((unsigned)(data & 0xff)); +} + +void write16bit(int data) { + + eputc((unsigned)((data & 0xff00) >> 8)); + eputc((unsigned)(data & 0xff)); +} + +int eputc(unsigned char c) { + + int return_val; + + if ((Mf_putc) == NULLFUNC) { + mferror("Mf_putc undefined"); + return(-1); + } + + return_val = (*Mf_putc)(c); + + if (return_val == EOF) mferror("error writing"); + Mf_numbyteswritten++; + return(return_val); +} + +char *mknote(int pitch) { + + static char * Notes [] = + {"c","c#","d","d#","e","f","f#","g","g#","a","a#","b"}; + static char buf[5]; + if ( notes ) + sprintf (buf,"%s%d",Notes[pitch % 12], pitch/12); + else + sprintf (buf,"%d",pitch); + return buf; +} + +myheader(int format,int ntrks,int division) { + + if (division & 0x8000) { + times = 0; + printf("MFile %d %d %d %d\n", + format,ntrks,-((-(division>>8))&0xff),division&0xff); + } else { + printf("MFile %d %d %d\n",format,ntrks,division); + } + if (format > 2) { + fprintf(stderr, "Can't deal with format %d files\n",format); + exit (1); + } + Beat = Clicks = division; + TrksToDo = ntrks; +} + +mytrstart() { + + printf("MTrk\n"); + TrkNr ++; +} + +mytrend() { + + printf("TrkEnd\n"); + --TrksToDo; +} + +mynon(int chan,int pitch,int vol) { + + prtime(); + printf(Onmsg,chan+1,mknote(pitch),vol); +} + +mynoff(int chan,int pitch,int vol) { + + prtime(); + printf(Offmsg,chan+1,mknote(pitch),vol); +} + +mypressure(int chan,int pitch,int press) { + + prtime(); + printf(PoPrmsg,chan+1,mknote(pitch),press); +} + +myparameter(int chan,int control,int value) { + + prtime(); + printf(Parmsg,chan+1,control,value); +} + +mypitchbend(int chan,int lsb,int msb) { + + prtime(); + printf(Pbmsg,chan+1,128*msb+lsb); +} + +myprogram(int chan,int program) { + + prtime(); + printf(PrChmsg,chan+1,program); +} + +mychanpressure(int chan,int press) { + + prtime(); + printf(ChPrmsg,chan+1,press); +} + +mysysex(int leng,char *mess) { + + prtime(); + printf("SysEx"); + prhex (mess, leng); +} + +mymmisc(int type,int leng,char *mess) { + + prtime(); + printf("Meta 0x%02x",type); + prhex(mess, leng); +} + +mymspecial(int leng,char *mess) { + + prtime(); + printf("SeqSpec"); + prhex(mess, leng); +} + +mymtext(int type,int leng,char *mess) { + + static char *ttype[] = { + NULL, + "Text","Copyright","TrkName","InstrName","Lyric","Marker","Cue","Unrec" + }; + int unrecognized = (sizeof(ttype)/sizeof(char *)) - 1; + prtime(); + if (type < 1 || type > unrecognized) + printf("Meta 0x%02x ",type); + else if (type == 3 && TrkNr == 1) + printf("Meta SeqName "); + else + printf("Meta %s ",ttype[type]); + prtext (mess, leng); +} + +mymseq(int num) { + + prtime(); + printf("SeqNr %d\n",num); +} + +mymeot() { + + prtime(); + printf("Meta TrkEnd\n"); +} + +mykeysig(int sf,int mi) { + + prtime(); + printf("KeySig %d %s\n",(sf>127?sf-256:sf),(mi?"minor":"major")); +} + +mytempo(long tempo) { + + prtime(); + printf("Tempo %ld\n",tempo); +} + +mytimesig(int nn,int dd,int cc,int bb) { + + int denom = 1; + + while (dd-- > 0) denom *= 2; + prtime(); + printf("TimeSig %d/%d %d %d\n",nn,denom,cc,bb); + M0 += (Mf_currtime-T0)/(Beat*Measure); + T0 = Mf_currtime; + Measure = nn; + Beat = 4 * Clicks / denom; +} + +mysmpte(int hr,int mn,int se,int fr,int ff) { + + prtime(); + printf("SMPTE %d %d %d %d %d\n",hr,mn,se,fr,ff); +} + +myarbitrary(int leng,char *mess) { + + prtime(); + printf("Arb",leng); + prhex(mess, leng); +} + +prtime() { + + if (times) { + long m = (Mf_currtime-T0)/Beat; + if (verbose) + printf("%03ld:%02ld:%03ld ", + m/Measure+M0,m%Measure,(Mf_currtime-T0)%Beat); + else + printf("%ld:%ld:%ld ", + m/Measure+M0,m%Measure,(Mf_currtime-T0)%Beat); + } else { + if (verbose) + printf("%-10ld ",Mf_currtime); + else + printf("%ld ",Mf_currtime); + } +} + +prtext(unsigned char *p,int leng) { + + int n, c; + int pos = 25; + + printf("\""); + for ( n=0; n= fold) { + printf ("\\\n\t"); + pos = 13; /* tab + \xab + \ */ + if (c == ' ' || c == '\t') { + putchar ('\\'); + ++pos; + } + } + switch (c) { + case '\\': + case '"': + printf ("\\%c", c); + pos += 2; + break; + case '\r': + printf ("\\r"); + pos += 2; + break; + case '\n': + printf ("\\n"); + pos += 2; + break; + case '\0': + printf ("\\0"); + pos += 2; + break; + default: + if (isprint(c)) { + putchar(c); + ++pos; + } else { + printf("\\x%02x" , c); + pos += 4; + } + } + } + printf("\"\n"); +} + +prhex(unsigned char *p,int leng) { + + int n; + int pos = 25; + + for(n=0; n= fold) { + printf ("\\\n\t%02x",*p); + pos = 14; + } else { + printf(" %02x",*p); + pos += 3; + } + } + printf("\n"); +} + +myerror(char *s) { + + if (TrksToDo <= 0) + fprintf(stderr,"Error: Garbage at end\n",s); + else + fprintf(stderr,"Error: %s\n",s); +} + +initfuncs() { + + Mf_error = myerror; + Mf_header = myheader; + Mf_starttrack = mytrstart; + Mf_endtrack = mytrend; + Mf_on = mynon; + Mf_off = mynoff; + Mf_pressure = mypressure; + Mf_parameter = myparameter; + Mf_pitchbend = mypitchbend; + Mf_program = myprogram; + Mf_chanpressure = mychanpressure; + Mf_sysex = mysysex; + Mf_metamisc = mymmisc; + Mf_seqnum = mymseq; + Mf_eot = mymeot; + Mf_timesig = mytimesig; + Mf_smpte = mysmpte; + Mf_tempo = mytempo; + Mf_keysig = mykeysig; + Mf_sqspecific = mymspecial; + Mf_text = mymtext; + Mf_arbitrary = myarbitrary; +} + +prs_error(char *s) { + + int c; + int count; + int ln = (eol_seen? lineno-1 : lineno); + fprintf (stderr, "%d: %s\n", ln, s); + if (yyleng > 0 && *yytext != '\n') + fprintf (stderr, "*** %*s ***\n", yyleng, yytext); + count = 0; + while (count < 100 && + (c=yylex()) != EOL && c != EOF) count++/* skip rest of line */; + if (c == EOF) exit(1); + if (err_cont) + longjmp (erjump,1); +} + +syntax() { + + prs_error("Syntax error"); +} + +translate() { + + if (yylex() == MTHD) { + Format = getint("MFile format"); + Ntrks = getint("MFile #tracks"); + Clicks = getint("MFile Clicks"); + if (Clicks < 0) + Clicks = (Clicks&0xff)<<8|getint("MFile SMPTE division"); + checkeol(); + mfwrite(Format, Ntrks, Clicks, F); + } else { + fprintf (stderr, "Missing MFile - can't continue\n"); + exit(1); + } +} + +static int mywritetrack() { + + int opcode, c; + long currtime = 0; + long newtime, delta; + int i, k; + + while ((opcode = yylex()) == EOL) ; + if (opcode != MTRK) prs_error("Missing MTrk"); + checkeol(); + while(1) { + err_cont = 1; + setjmp (erjump); + switch(yylex()) { + case MTRK: + prs_error("Unexpected MTrk"); + case EOF: + err_cont = 0; + error("Unexpected EOF"); + return -1; + case TRKEND: + err_cont = 0; + checkeol(); + return 1; + case INT: + newtime = yyval; + if ((opcode=yylex())=='/') { + if (yylex()!=INT) prs_error("Illegal time value"); + newtime = (newtime-M0)*Measure+yyval; + if (yylex()!='/'||yylex()!=INT) prs_error("Illegal time value"); + newtime = T0 + newtime*Beat + yyval; + opcode = yylex(); + } + delta = newtime - currtime; + switch(opcode) { + case ON: + case OFF: + case POPR: + checkchan(); + checknote(); + checkval(); + mf_w_midi_event(delta,opcode,chan,data,2L); + break; + case PAR: + checkchan(); + checkcon(); + checkval(); + mf_w_midi_event(delta,opcode,chan,data,2L); + break; + case PB: + checkchan(); + splitval(); + mf_w_midi_event(delta,opcode,chan,data,2L); + break; + case PRCH: + checkchan(); + checkprog(); + mf_w_midi_event(delta,opcode,chan,data,1L); + break; + case CHPR: + checkchan(); + checkval(); + data[0] = data[1]; + mf_w_midi_event(delta,opcode,chan,data,1L); + break; + case SYSEX: + case ARB: + gethex(); + mf_w_sysex_event(delta,buffer,(long)buflen); + break; + case TEMPO: + if (yylex() != INT) syntax(); + mf_w_tempo (delta,yyval); + break; + case TIMESIG: { + int nn,denom,cc,bb; + if (yylex() != INT || yylex() != '/') syntax(); + nn = yyval; + denom = getbyte("Denom"); + cc = getbyte("clocks per click"); + bb = getbyte("32nd notes per 24 clocks"); + for(i=0, k=1 ; k 7) + error("Key Sig must be between -7 and 7"); + if ((c=yylex()) != MINOR && c != MAJOR) + syntax(); + data[1] = (c == MINOR); + mf_w_meta_event(delta,key_signature,data,2L); + break; + case SEQNR: + get16val("SeqNr"); + mf_w_meta_event(delta,sequence_number,data,2L); + break; + case META: { + int type = yylex(); + switch(type) { + case TRKEND: type = end_of_track; break; + case TEXT: + case COPYRIGHT: + case SEQNAME: + case INSTRNAME: + case LYRIC: + case MARKER: + case CUE: type -= (META+1); break; + case INT: type = yyval; break; + default: prs_error("Illegal Meta type"); + } + if (type == end_of_track) + buflen = 0; + else + gethex(); + mf_w_meta_event(delta,type,buffer,(long)buflen); + break; + } + case SEQSPEC: + gethex(); + mf_w_meta_event(delta,sequencer_specific,buffer,(long)buflen); + break; + default: + prs_error("Unknown input"); + break; + } + currtime = newtime; + case EOL: + break; + default: + prs_error("Unknown input"); + break; + } + checkeol(); + } +} + +getbyte(char *mess) { + + char ermesg[100]; + + getint(mess); + if (yyval < 0 || yyval > 127) { + sprintf(ermesg,"Wrong value (%ld) for %s",yyval,mess); + error(ermesg); + yyval = 0; + } + return yyval; +} + +getint(char *mess) { + + char ermesg[100]; + if (yylex() != INT) { + sprintf(ermesg,"Integer expected for %s",mess); + error(ermesg); + yyval = 0; + } + return yyval; +} + +static void checkchan() { + + if (yylex() != CH || yylex() != INT) syntax(); + if (yyval < 1 || yyval > 16) error("Chan must be between 1 and 16"); + chan = yyval-1; +} + +static void checknote() { + + int c; + + if (yylex() != NOTE || ((c=yylex()) != INT && c != NOTEVAL)) + syntax(); + if (c == NOTEVAL) { + static int notes[] = {9,11,0,2,4,5,7}; + char *p = yytext; + c = *p++; + if (isupper(c)) c = tolower(c); + yyval = notes[c-'a']; + switch(*p) { + case '#': + case '+': yyval++; p++; break; + case 'b': + case 'B': + case '-': yyval--; p++; break; + } + yyval += 12 * atoi(p); + } + if (yyval < 0 || yyval > 127) + error("Note must be between 0 and 127"); + data[0] = yyval; +} + +static void checkval() { + + if (yylex() != VAL || yylex() != INT) syntax(); + if (yyval < 0 || yyval > 127) + error("Value must be between 0 and 127"); + data[1] = yyval; +} + +static void splitval() { + + if (yylex() != VAL || yylex() != INT) syntax(); + if (yyval < 0 || yyval > 16383) + error("Value must be between 0 and 16383"); + data[0] = yyval%128; + data[1] = yyval/128; +} + +static void get16val() { + + if (yylex() != VAL || yylex() != INT) syntax(); + if (yyval < 0 || yyval > 65535) + error("Value must be between 0 and 65535"); + data[0] = (yyval>>8)&0xff; + data[1] = yyval&0xff; +} + +static void checkcon() { + + if (yylex() != CON || yylex() != INT) + syntax(); + if (yyval < 0 || yyval > 127) + error("Controller must be between 0 and 127"); + data[0] = yyval; +} + +static void checkprog() { + + if (yylex() != PROG || yylex() != INT) syntax(); + if (yyval < 0 || yyval > 127) + error("Program number must be between 0 and 127"); + data[0] = yyval; +} + +static void checkeol() { + + if (eol_seen) return; + if (yylex() != EOL) { + prs_error ("Garbage deleted"); + while (!eol_seen) yylex(); + } +} + +static void gethex() { + + int c; + + buflen = 0; + do_hex = 1; + c = yylex(); + if (c == STRING) { + int i = 0; + if (yyleng-1 > bufsiz) { + bufsiz = yyleng-1; + if (buffer) + buffer = realloc(buffer, bufsiz); + else + buffer = malloc (bufsiz); + if (! buffer) error("Out of memory"); + } + while(i= bufsiz) { + bufsiz += 128; + if (buffer) + buffer = realloc(buffer,bufsiz); + else + buffer = malloc(bufsiz); + if (! buffer) error ("Out of memory"); + } + buffer[buflen++] = yyval; + c = yylex(); + } while (c == INT); + if (c != EOL) prs_error("Unknown hex input"); + } else { + prs_error("String or hex input expected"); + } +} + +long bankno (char *s,int n) { + + long res = 0; + int c; + while(n-- > 0) { + c = (*s++); + if (islower(c)) + c -= 'a'; + else if (isupper(c)) + c -= 'A'; + else + c -= '1'; + res = res * 8 + c; + } + return res; +} + + +FILE *efopen(char *name,char *mode) { +if (dbg) fprintf(stderr,"efopen(%s,%s)\n",name,mode); + + FILE *f; + if ((f = fopen(name,mode)) == NULL) { + (void) fprintf(stderr,"Cannot open '%s', %s!\n",name,strerror(errno)); + exit(1); + } + return(f); +} + +fileputc(int c) { + + return putc(c,F); +} + +int filegetc() { + + return(getc(F)); +} diff --git a/tools/midicomp-0.0.4/midicomp.h b/tools/midicomp-0.0.4/midicomp.h new file mode 100644 index 0000000..961bfd5 --- /dev/null +++ b/tools/midicomp-0.0.4/midicomp.h @@ -0,0 +1,252 @@ +/* +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., +59 Temple Place, Suite 330, Boston, +MA 02111-1307 USA +*/ + +#define MThd 0x4d546864L +#define MTrk 0x4d54726bL +#define MTHD 256 +#define MTRK 257 +#define TRKEND 258 + +#define ON note_on +#define OFF note_off +#define POPR poly_aftertouch +#define PAR control_change +#define PB pitch_wheel +#define PRCH program_chng +#define CHPR channel_aftertouch +#define SYSEX system_exclusive + +#define ARB 259 +#define MINOR 260 +#define MAJOR 261 + +#define CH 262 +#define NOTE 263 +#define VAL 264 +#define CON 265 +#define PROG 266 + +#define INT 267 +#define STRING 268 +#define STRESC 269 +#define ERR 270 +#define NOTEVAL 271 +#define EOL 272 + +#define META 273 +#define SEQSPEC (META+1+sequencer_specific) +#define TEXT (META+1+text_event) +#define COPYRIGHT (META+1+copyright_notice) +#define SEQNAME (META+1+sequence_name) +#define INSTRNAME (META+1+instrument_name) +#define LYRIC (META+1+lyric) +#define MARKER (META+1+marker) +#define CUE (META+1+cue_point) +#define SEQNR (META+1+sequence_number) +#define KEYSIG (META+1+key_signature) +#define TEMPO (META+1+set_tempo) +#define TIMESIG (META+1+time_signature) +#define SMPTE (META+1+smpte_offset) + +#define note_off 0x80 +#define note_on 0x90 +#define poly_aftertouch 0xa0 +#define control_change 0xb0 +#define program_chng 0xc0 +#define channel_aftertouch 0xd0 +#define pitch_wheel 0xe0 +#define system_exclusive 0xf0 +#define delay_packet (1111) + +#define damper_pedal 0x40 +#define portamento 0x41 +#define sostenuto 0x42 +#define soft_pedal 0x43 +#define general_4 0x44 +#define hold_2 0x45 +#define general_5 0x50 +#define general_6 0x51 +#define general_7 0x52 +#define general_8 0x53 +#define tremolo_depth 0x5c +#define chorus_depth 0x5d +#define detune 0x5e +#define phaser_depth 0x5f + +#define data_inc 0x60 +#define data_dec 0x61 + +#define non_reg_lsb 0x62 +#define non_reg_msb 0x63 +#define reg_lsb 0x64 +#define reg_msb 0x65 + +#define meta_event 0xFF +#define sequence_number 0x00 +#define text_event 0x01 +#define copyright_notice 0x02 +#define sequence_name 0x03 +#define instrument_name 0x04 +#define lyric 0x05 +#define marker 0x06 +#define cue_point 0x07 +#define channel_prefix 0x20 +#define end_of_track 0x2f +#define set_tempo 0x51 +#define smpte_offset 0x54 +#define time_signature 0x58 +#define key_signature 0x59 +#define sequencer_specific 0x7f + +#define Seq_Circuits (0x01) /* Sequential Circuits Inc. */ +#define Big_Briar (0x02) /* Big Briar Inc. */ +#define Octave (0x03) /* Octave/Plateau */ +#define Moog (0x04) /* Moog Music */ +#define Passport (0x05) /* Passport Designs */ +#define Lexicon (0x06) /* Lexicon */ +#define Tempi (0x20) /* Bon Tempi */ +#define Siel (0x21) /* S.I.E.L. */ +#define Kawai (0x41) +#define Roland (0x42) +#define Korg (0x42) +#define Yamaha (0x43) + +#define lowerbyte(x) ((unsigned char)(x & 0xff)) +#define upperbyte(x) ((unsigned char)((x & 0xff00)>>8)) +#define NULLFUNC 0 +#define MSGINCREMENT 128 + +#ifdef NO_YYLENG_VAR +#define yyleng yylength +#endif + +static FILE *F; + +static char *Msgbuff = NULL; +static int Msgsize = 0; +static int Msgindex = 0; + +static int TrkNr; +static int TrksToDo = 1; +static int Measure, M0, Beat, Clicks; +static long T0; + +static int fold = 0; +static int notes = 0; +static int times = 0; +static char *Onmsg = "On ch=%d n=%s v=%d\n"; +static char *Offmsg = "Off ch=%d n=%s v=%d\n"; +static char *PoPrmsg = "PoPr ch=%d n=%s v=%d\n"; +static char *Parmsg = "Par ch=%d c=%d v=%d\n"; +static char *Pbmsg = "Pb ch=%d v=%d\n"; +static char *PrChmsg = "PrCh ch=%d p=%d\n"; +static char *ChPrmsg = "ChPr ch=%d v=%d\n"; +static jmp_buf erjump; +static int err_cont = 0; +static int TrkNr; +static int Format, Ntrks; +static int Measure, M0, Beat, Clicks; +static long T0; +static char* buffer = 0; +static int buflen,bufsiz= 0; + +extern long yyval; +extern int yyleng; +extern int lineno; +extern char *yytext; +extern int do_hex; +extern int eol_seen; +extern FILE *yyin; + +static int mywritetrack(); +static void checkchan(); +static void checknote(); +static void checkval(); +static void splitval(); +static void get16val(); +static void checkcon(); +static void checkprog(); +static void checkeol(); +static void gethex(); + +int (*Mf_getc)() = NULLFUNC; +int (*Mf_error)() = NULLFUNC; +int (*Mf_header)() = NULLFUNC; +int (*Mf_starttrack)() = NULLFUNC; +int (*Mf_endtrack)() = NULLFUNC; +int (*Mf_on)() = NULLFUNC; +int (*Mf_off)() = NULLFUNC; +int (*Mf_pressure)() = NULLFUNC; +int (*Mf_parameter)() = NULLFUNC; +int (*Mf_pitchbend)() = NULLFUNC; +int (*Mf_program)() = NULLFUNC; +int (*Mf_chanpressure)() = NULLFUNC; +int (*Mf_sysex)() = NULLFUNC; +int (*Mf_arbitrary)() = NULLFUNC; +int (*Mf_metamisc)() = NULLFUNC; +int (*Mf_seqnum)() = NULLFUNC; +int (*Mf_eot)() = NULLFUNC; +int (*Mf_smpte)() = NULLFUNC; +int (*Mf_tempo)() = NULLFUNC; +int (*Mf_timesig)() = NULLFUNC; +int (*Mf_keysig)() = NULLFUNC; +int (*Mf_sqspecific)() = NULLFUNC; +int (*Mf_text)() = NULLFUNC; + +static readtrack(); +static badbyte(); +static metaevent(); +static sysex(); +static chanmessage(); +static msginit(); +static msgleng(); +static msgadd(); +static biggermsg(); + +float mf_ticks2sec(); +unsigned long mf_sec2ticks(float,int,unsigned int); +void mfwrite(); + +int (*Mf_putc)() = NULLFUNC; +int (*Mf_wtrack)() = NULLFUNC; +int (*Mf_wtempotrack)() = NULLFUNC; + +int Mf_nomerge = 0; +long Mf_currtime = 0L; + +static long Mf_toberead = 0L; +static long Mf_numbyteswritten = 0L; + +static long readvarinum(); +static long read32bit(); +static long to32bit(); +static int read16bit(); +static int to16bit(); +static char *msg(); +static void readheader(); + +static int verbose_flag; +static int dbg=0; +char data[5]; +int chan; +int Mf_RunStat = 0; +static int laststat; +static int lastmeta; +int verbose = 0; + +int filegetc(); +int fileputc(); +void WriteVarLen(); +int eputc(unsigned char); diff --git a/tools/midicomp-0.0.4/midifile.h b/tools/midicomp-0.0.4/midifile.h new file mode 100644 index 0000000..d414196 --- /dev/null +++ b/tools/midicomp-0.0.4/midifile.h @@ -0,0 +1,121 @@ +/* $Id: midifile.h,v 1.3 1991/11/03 21:50:50 piet Rel $ */ + +static readtrack(); +static badbyte(); +static metaevent(); +static sysex(); +static chanmessage(); +static msginit(); +static msgleng(); +static msgadd(); +static biggermsg(); + +/* definitions for MIDI file parsing code */ +extern int (*Mf_getc)(); +extern int (*Mf_header)(); +extern int (*Mf_starttrack)(); +extern int (*Mf_endtrack)(); +extern int (*Mf_on)(); +extern int (*Mf_off)(); +extern int (*Mf_pressure)(); +extern int (*Mf_parameter)(); +extern int (*Mf_pitchbend)(); +extern int (*Mf_program)(); +extern int (*Mf_chanpressure)(); +extern int (*Mf_sysex)(); +extern int (*Mf_metamisc)(); +extern int (*Mf_sqspecific)(); +extern int (*Mf_seqnum)(); +extern int (*Mf_text)(); +extern int (*Mf_eot)(); +extern int (*Mf_timesig)(); +extern int (*Mf_smpte)(); +extern int (*Mf_tempo)(); +extern int (*Mf_keysig)(); +extern int (*Mf_arbitrary)(); +extern int (*Mf_error)(); +extern long Mf_currtime; +extern int Mf_nomerge; + +/* definitions for MIDI file writing code */ +extern int (*Mf_putc)(); +extern int (*Mf_wtrack)(); +extern int (*Mf_wtempotrack)(); +float mf_ticks2sec(); +unsigned long mf_sec2ticks(); +void mfwrite(); + +/* MIDI status commands most significant bit is 1 */ +#define note_off 0x80 +#define note_on 0x90 +#define poly_aftertouch 0xa0 +#define control_change 0xb0 +#define program_chng 0xc0 +#define channel_aftertouch 0xd0 +#define pitch_wheel 0xe0 +#define system_exclusive 0xf0 +#define delay_packet (1111) + +/* 7 bit controllers */ +#define damper_pedal 0x40 +#define portamento 0x41 +#define sostenuto 0x42 +#define soft_pedal 0x43 +#define general_4 0x44 +#define hold_2 0x45 +#define general_5 0x50 +#define general_6 0x51 +#define general_7 0x52 +#define general_8 0x53 +#define tremolo_depth 0x5c +#define chorus_depth 0x5d +#define detune 0x5e +#define phaser_depth 0x5f + +/* parameter values */ +#define data_inc 0x60 +#define data_dec 0x61 + +/* parameter selection */ +#define non_reg_lsb 0x62 +#define non_reg_msb 0x63 +#define reg_lsb 0x64 +#define reg_msb 0x65 + +/* Standard MIDI Files meta event definitions */ +#define meta_event 0xFF +#define sequence_number 0x00 +#define text_event 0x01 +#define copyright_notice 0x02 +#define sequence_name 0x03 +#define instrument_name 0x04 +#define lyric 0x05 +#define marker 0x06 +#define cue_point 0x07 +#define channel_prefix 0x20 +#define end_of_track 0x2f +#define set_tempo 0x51 +#define smpte_offset 0x54 +#define time_signature 0x58 +#define key_signature 0x59 +#define sequencer_specific 0x7f + +/* Manufacturer's ID number */ +#define Seq_Circuits (0x01) /* Sequential Circuits Inc. */ +#define Big_Briar (0x02) /* Big Briar Inc. */ +#define Octave (0x03) /* Octave/Plateau */ +#define Moog (0x04) /* Moog Music */ +#define Passport (0x05) /* Passport Designs */ +#define Lexicon (0x06) /* Lexicon */ +#define Tempi (0x20) /* Bon Tempi */ +#define Siel (0x21) /* S.I.E.L. */ +#define Kawai (0x41) +#define Roland (0x42) +#define Korg (0x42) +#define Yamaha (0x43) + +/* miscellaneous definitions */ +#define MThd 0x4d546864L +#define MTrk 0x4d54726bL +#define lowerbyte(x) ((unsigned char)(x & 0xff)) +#define upperbyte(x) ((unsigned char)((x & 0xff00)>>8)) diff --git a/tools/midicomp-0.0.4/t2mf.fl b/tools/midicomp-0.0.4/t2mf.fl new file mode 100644 index 0000000..5ea1aa6 --- /dev/null +++ b/tools/midicomp-0.0.4/t2mf.fl @@ -0,0 +1,98 @@ +/* $Id: t2mf.fl,v 1.3 1991/11/15 19:31:00 piet Rel $ */ + +%{ + +#include "t2mf.h" + +#ifdef NO_YYLENG_VAR +int yylength; +#define YY_USER_ACTION yylength = yyleng +#endif + +int do_hex = 0; +int eol_seen = 0; +int lineno = 1; +long yyval; +long bankno(); + +%} + +Hex [0-9a-f] + +%x QUOTE +%x HEX +%% + if (do_hex) { + BEGIN(HEX); + do_hex = 0; + } + eol_seen = 0; + +[ \t\r] /* skip whitespace */; +"#".*\n /* skip comment */ lineno++; + +MFile return MTHD; +MTrk return MTRK; +TrkEnd return TRKEND; + +On return ON; +Off return OFF; +Po(ly)?Pr return POPR; +Par(am)? return PAR; +Pb return PB; +Pr(og)?Ch return PRCH; +Ch(an)?Pr return CHPR; +SysEx return SYSEX; +Meta return META; +SeqSpec return SEQSPEC; +Text return TEXT; +Copyright return COPYRIGHT; +TrkName|SeqName return SEQNAME; +InstrName return INSTRNAME; +Lyric return LYRIC; +Marker return MARKER; +Cue return CUE; +SeqNr return SEQNR; +KeySig return KEYSIG; +Tempo return TEMPO; +TimeSig return TIMESIG; +SMPTE return SMPTE; +Arb return ARB; +[:/] return '/'; + +minor return MINOR; +major return MAJOR; + +ch= return CH; +n(ote)?= return NOTE; +v([oa]l)?= return VAL; +c(on)?= return CON; +p(rog)?= return PROG; + +[-+]?[0-9]+ sscanf (yytext, "%ld", &yyval); return INT; +0x{Hex}+ sscanf (yytext+2, "%lx", &yyval); return INT; +\$[A-H1-8]+ yyval = bankno (yytext+1, yyleng-1); return INT; +{Hex}{Hex}? sscanf (yytext, "%lx", &yyval); return INT; + +[a-g][#b+-]?[0-9]+ return NOTEVAL; + +\" BEGIN (QUOTE); +[^\\"\n]* yymore(); +\" BEGIN (0); return STRING; +\\(.|\n) yymore(); +\n { error ("unterminated string"); + lineno++; eol_seen++; BEGIN(0); return EOL; + } +<> error ("EOF in string"); return EOF; + +\\[ \t\r]*\n lineno++; +\n lineno++; eol_seen++; BEGIN(0); return EOL; + +[g-z][a-z]+ BEGIN (0); return ERR; +. BEGIN (0); return ERR; +[a-z]+ return ERR; +. return ERR; + +<> return EOF; + +%% diff --git a/tools/midicomp-0.0.4/t2mf.h b/tools/midicomp-0.0.4/t2mf.h new file mode 100644 index 0000000..b6532d4 --- /dev/null +++ b/tools/midicomp-0.0.4/t2mf.h @@ -0,0 +1,48 @@ +/* $Id: t2mf.h,v 1.2 1991/11/03 21:50:50 piet Rel $ */ +#include "midifile.h" +#include + +#define MTHD 256 +#define MTRK 257 +#define TRKEND 258 + +#define ON note_on +#define OFF note_off +#define POPR poly_aftertouch +#define PAR control_change +#define PB pitch_wheel +#define PRCH program_chng +#define CHPR channel_aftertouch +#define SYSEX system_exclusive + +#define ARB 259 +#define MINOR 260 +#define MAJOR 261 + +#define CH 262 +#define NOTE 263 +#define VAL 264 +#define CON 265 +#define PROG 266 + +#define INT 267 +#define STRING 268 +#define STRESC 269 +#define ERR 270 +#define NOTEVAL 271 +#define EOL 272 + +#define META 273 +#define SEQSPEC (META+1+sequencer_specific) +#define TEXT (META+1+text_event) +#define COPYRIGHT (META+1+copyright_notice) +#define SEQNAME (META+1+sequence_name) +#define INSTRNAME (META+1+instrument_name) +#define LYRIC (META+1+lyric) +#define MARKER (META+1+marker) +#define CUE (META+1+cue_point) +#define SEQNR (META+1+sequence_number) +#define KEYSIG (META+1+key_signature) +#define TEMPO (META+1+set_tempo) +#define TIMESIG (META+1+time_signature) +#define SMPTE (META+1+smpte_offset) diff --git a/tools/midicomp-0.0.4/t2mflex.c b/tools/midicomp-0.0.4/t2mflex.c new file mode 100644 index 0000000..55d0a60 --- /dev/null +++ b/tools/midicomp-0.0.4/t2mflex.c @@ -0,0 +1,1385 @@ +/* A lexical scanner generated by flex */ + +/* scanner skeleton version: + * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $ + */ + +#define FLEX_SCANNER + +#include + +void *malloc( size_t ); +void free( void* ); + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#include + +/* use prototypes in function declarations */ +#define YY_USE_PROTOS + +/* the "const" storage-class-modifier is valid */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#ifdef __STDC__ + +#ifdef __GNUC__ +#include +#else +#include +#endif /* __GNUC__ */ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + + +#ifdef __TURBOC__ +#define YY_USE_CONST +#endif + +#ifdef atarist +#include +#include +#include +#define YY_INPUT(buf,result,max_size) \ + if ( (result = _yyread( fileno(yyin), (char *) buf, max_size )) < 0 ) \ + YY_FATAL_ERROR( "read() in flex scanner failed" ); +#endif + + +#ifndef YY_USE_CONST +#define const +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +/* we can't get here if it's an ANSI C compiler, or a C++ compiler, + * so it's got to be a K&R compiler, and therefore there's no standard + * place from which to include these definitions + */ +int read(); +#endif + + +/* amount of stuff to slurp up with each read */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* returned upon end-of-file */ +#define YY_END_TOK 0 + +/* copy whatever the last rule matched to the standard output */ + +/* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */ +/* this used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite() + */ +#define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout ) + +/* gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \ + YY_FATAL_ERROR( "read() in flex scanner failed" ); +#endif +#define YY_NULL 0 + +/* no semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#define yyterminate() return ( YY_NULL ) + +/* report a fatal error */ + +/* The funky do-while is used to turn this macro definition into + * a single C statement (which needs a semi-colon terminator). + * This avoids problems with code like: + * + * if ( something_happens ) + * YY_FATAL_ERROR( "oops, the something happened" ); + * else + * everything_okay(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the YY_FATAL_ERROR() call. + */ + +#define YY_FATAL_ERROR(msg) \ + do \ + { \ + (void) fputs( msg, stderr ); \ + (void) putc( '\n', stderr ); \ + exit( 1 ); \ + } \ + while ( 0 ) + +/* default yywrap function - always treat EOF as an EOF */ +#define yywrap() 1 + +/* enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN + */ +#define BEGIN yy_start = 1 + 2 * + +/* action number for EOF rule of a given start state */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* special action meaning "start processing a new file" */ +#define YY_NEW_FILE \ + do \ + { \ + yy_init_buffer( yy_current_buffer, yyin ); \ + yy_load_buffer_state(); \ + } \ + while ( 0 ) + +/* default declaration of generated scanner - a define so the user can + * easily add parameters + */ +#define YY_DECL int yylex YY_PROTO(( void )) + +/* code executed at the end of each rule */ +#define YY_BREAK break; + +#define YY_END_OF_BUFFER_CHAR 0 + +#ifndef YY_BUF_SIZE +#define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */ +#endif + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +#define YY_CHAR char +# line 1 "t2mf.fl" +#define INITIAL 0 +/* $Id: t2mf.fl,v 1.3 1991/11/15 19:31:00 piet Rel $ */ +# line 4 "t2mf.fl" + +#include "t2mf.h" + +#ifdef NO_YYLENG_VAR +int yylength; +#define YY_USER_ACTION yylength = yyleng +#endif + +int do_hex = 0; +int eol_seen = 0; +int lineno = 1; +long yyval; +long bankno(); + +#define QUOTE 1 +#define HEX 2 +# line 24 "t2mf.fl" + +/* done after the current pattern has been matched and before the + * corresponding action - sets up yytext + */ +#define YY_DO_BEFORE_ACTION \ + yytext = yy_bp; \ + yytext -= yy_more_len; \ + yyleng = yy_cp - yytext; \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* return all but the first 'n' matched characters back to the input stream */ +#define yyless(n) \ + do \ + { \ + /* undo effects of setting up yytext */ \ + *yy_cp = yy_hold_char; \ + yy_c_buf_p = yy_cp = yy_bp + n; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext ) + + +struct yy_buffer_state + { + FILE *yy_input_file; + + YY_CHAR *yy_ch_buf; /* input buffer */ + YY_CHAR *yy_buf_pos; /* current position in input buffer */ + + /* size of input buffer in bytes, not including room for EOB characters*/ + int yy_buf_size; + + /* number of characters read into yy_ch_buf, not including EOB characters */ + int yy_n_chars; + + int yy_eof_status; /* whether we've seen an EOF on this buffer */ +#define EOF_NOT_SEEN 0 + /* "pending" happens when the EOF has been seen but there's still + * some text process + */ +#define EOF_PENDING 1 +#define EOF_DONE 2 + }; + +static YY_BUFFER_STATE yy_current_buffer; + +/* we provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state" + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed */ +static YY_CHAR yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + + +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +#ifndef YY_USER_INIT +#define YY_USER_INIT +#endif + +extern YY_CHAR *yytext; +extern int yyleng; +extern FILE *yyin, *yyout; + +YY_CHAR *yytext; +int yyleng; + +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; + +#define YY_END_OF_BUFFER 56 +typedef int yy_state_type; +static const short int yy_accept[185] = + { 0, + 0, 0, 43, 43, 0, 0, 56, 53, 1, 49, + 42, 53, 53, 53, 29, 37, 37, 53, 52, 52, + 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, + 52, 52, 43, 46, 44, 55, 51, 1, 42, 51, + 40, 51, 51, 0, 2, 39, 37, 0, 0, 48, + 0, 41, 52, 52, 52, 35, 52, 52, 52, 52, + 52, 52, 52, 52, 52, 52, 52, 33, 52, 52, + 6, 36, 52, 10, 52, 52, 52, 52, 52, 52, + 52, 52, 34, 52, 43, 45, 40, 50, 38, 28, + 32, 52, 52, 52, 52, 22, 52, 52, 52, 52, + + 52, 52, 52, 52, 52, 52, 7, 9, 52, 52, + 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, + 52, 12, 52, 52, 52, 52, 52, 52, 14, 52, + 52, 4, 52, 52, 52, 8, 11, 52, 52, 52, + 52, 52, 52, 16, 52, 52, 52, 52, 52, 52, + 20, 31, 52, 3, 30, 9, 52, 23, 52, 27, + 13, 25, 52, 52, 52, 52, 52, 24, 21, 52, + 52, 52, 5, 52, 52, 52, 18, 15, 26, 52, + 52, 17, 19, 0 + } ; + +static const YY_CHAR yy_ec[128] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 4, 5, 6, 1, 1, 1, 1, + 1, 1, 7, 1, 7, 1, 8, 9, 10, 10, + 10, 10, 10, 10, 10, 10, 11, 8, 1, 1, + 12, 1, 1, 1, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 36, + 1, 13, 1, 1, 1, 1, 14, 15, 16, 17, + + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 36, 1, 1, 1, 1, 1 + } ; + +static const short int yy_base[194] = + { 0, + 0, 0, 36, 38, 51, 0, 495, 496, 496, 496, + 496, 491, 0, 34, 496, 81, 37, 91, 114, 141, + 83, 91, 466, 474, 453, 94, 87, 78, 116, 88, + 118, 125, 0, 496, 496, 0, 496, 496, 496, 487, + 0, 107, 0, 486, 496, 0, 123, 0, 139, 496, + 148, 151, 0, 154, 473, 496, 154, 93, 469, 454, + 447, 453, 112, 450, 460, 454, 449, 496, 446, 459, + 0, 496, 446, 0, 78, 139, 446, 446, 442, 143, + 447, 448, 496, 446, 0, 496, 496, 0, 0, 0, + 496, 443, 438, 456, 429, 0, 433, 433, 442, 435, + + 438, 447, 435, 431, 434, 439, 0, 442, 417, 423, + 432, 432, 143, 418, 432, 420, 415, 429, 154, 434, + 416, 0, 413, 412, 420, 425, 409, 421, 0, 420, + 406, 0, 424, 409, 405, 0, 0, 161, 140, 404, + 414, 394, 402, 0, 397, 395, 407, 364, 358, 298, + 0, 0, 278, 0, 0, 0, 282, 0, 262, 0, + 0, 0, 257, 258, 247, 243, 248, 0, 0, 243, + 166, 159, 0, 160, 155, 148, 0, 0, 0, 105, + 32, 0, 0, 496, 183, 221, 250, 267, 305, 343, + 373, 379, 409 + + } ; + +static const short int yy_def[194] = + { 0, + 184, 1, 185, 185, 184, 5, 184, 184, 184, 184, + 184, 186, 187, 184, 184, 184, 184, 184, 188, 188, + 20, 188, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 189, 184, 184, 190, 184, 184, 184, 186, + 191, 184, 192, 186, 184, 187, 184, 193, 184, 184, + 184, 184, 22, 22, 22, 184, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 184, 22, 22, + 22, 184, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 184, 22, 189, 184, 184, 192, 193, 22, + 184, 22, 22, 22, 22, 22, 22, 22, 22, 22, + + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 0, 184, 184, 184, 184, 184, 184, + 184, 184, 184 + + } ; + +static const short int yy_nxt[535] = + { 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 17, 8, 18, 19, 20, 21, 20, 20, 20, 20, + 22, 23, 22, 24, 25, 26, 27, 28, 29, 22, + 22, 30, 31, 22, 32, 22, 22, 22, 34, 35, + 34, 35, 47, 47, 47, 47, 47, 47, 36, 183, + 36, 37, 38, 10, 39, 40, 37, 37, 37, 41, + 41, 41, 37, 42, 41, 41, 41, 41, 41, 41, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 47, + 47, 47, 49, 50, 56, 184, 70, 184, 68, 184, + + 184, 184, 109, 57, 71, 77, 110, 63, 49, 50, + 58, 64, 65, 78, 69, 66, 59, 48, 51, 94, + 51, 95, 52, 52, 52, 79, 67, 72, 54, 73, + 74, 47, 47, 47, 100, 80, 83, 182, 84, 81, + 49, 50, 101, 75, 55, 51, 76, 51, 82, 52, + 52, 52, 84, 157, 111, 54, 52, 52, 52, 52, + 52, 52, 52, 52, 52, 91, 112, 92, 116, 139, + 158, 146, 72, 181, 140, 180, 111, 177, 179, 117, + 147, 178, 93, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 46, + 177, 176, 175, 46, 46, 46, 46, 46, 46, 46, + 46, 53, 174, 53, 173, 53, 53, 53, 172, 171, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + + 53, 53, 53, 53, 53, 85, 85, 170, 169, 85, + 85, 85, 85, 85, 85, 85, 85, 168, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 86, 86, 86, 86, 86, 86, 86, + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + 86, 87, 87, 87, 167, 166, 87, 87, 87, 87, + 87, 87, 88, 88, 88, 88, 88, 88, 88, 88, + + 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, + 165, 164, 89, 89, 89, 89, 89, 89, 163, 162, + 161, 160, 159, 110, 156, 68, 155, 154, 153, 152, + 151, 150, 149, 148, 93, 83, 145, 144, 143, 142, + 141, 138, 137, 136, 135, 134, 133, 132, 131, 130, + 129, 128, 127, 126, 125, 124, 123, 56, 122, 121, + 120, 119, 118, 115, 114, 113, 108, 107, 106, 105, + 104, 103, 102, 99, 98, 97, 96, 90, 45, 45, + 62, 61, 60, 45, 184, 7, 184, 184, 184, 184, + + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184 + } ; + +static const short int yy_chk[535] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, + 4, 4, 14, 14, 14, 17, 17, 17, 3, 181, + 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 16, + 16, 16, 18, 18, 21, 22, 28, 22, 27, 22, + + 22, 22, 75, 21, 28, 30, 75, 26, 42, 42, + 21, 26, 26, 30, 27, 26, 21, 16, 19, 58, + 19, 58, 19, 19, 19, 30, 26, 29, 19, 29, + 29, 47, 47, 47, 63, 31, 32, 180, 32, 31, + 49, 49, 63, 29, 19, 20, 29, 20, 31, 20, + 20, 20, 32, 139, 76, 20, 51, 51, 51, 52, + 52, 52, 54, 54, 54, 57, 76, 57, 80, 113, + 139, 119, 138, 176, 113, 175, 138, 174, 172, 80, + 119, 171, 57, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 186, 186, 186, 186, 186, 186, 186, 186, 186, + 186, 186, 186, 186, 186, 186, 186, 186, 186, 186, + 186, 186, 186, 186, 186, 186, 186, 186, 186, 186, + 186, 186, 186, 186, 186, 186, 186, 186, 186, 187, + 170, 167, 166, 187, 187, 187, 187, 187, 187, 187, + 187, 188, 165, 188, 164, 188, 188, 188, 163, 159, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + 188, 188, 188, 188, 188, 188, 188, 188, 188, 188, + + 188, 188, 188, 188, 188, 189, 189, 157, 153, 189, + 189, 189, 189, 189, 189, 189, 189, 150, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 191, 191, 191, 149, 148, 191, 191, 191, 191, + 191, 191, 192, 192, 192, 192, 192, 192, 192, 192, + + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 193, 193, 193, + 147, 146, 193, 193, 193, 193, 193, 193, 145, 143, + 142, 141, 140, 135, 134, 133, 131, 130, 128, 127, + 126, 125, 124, 123, 121, 120, 118, 117, 116, 115, + 114, 112, 111, 110, 109, 108, 106, 105, 104, 103, + 102, 101, 100, 99, 98, 97, 95, 94, 93, 92, + 84, 82, 81, 79, 78, 77, 73, 70, 69, 67, + 66, 65, 64, 62, 61, 60, 59, 55, 44, 40, + 25, 24, 23, 12, 7, 184, 184, 184, 184, 184, + + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184 + } ; + +static yy_state_type yy_last_accepting_state; +static YY_CHAR *yy_last_accepting_cpos; + +/* the intent behind this definition is that it'll catch + * any uses of REJECT which flex missed + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_doing_yy_more = 0; +static int yy_more_len = 0; +#define yymore() { yy_more_flag = 1; } +#define YY_MORE_ADJ (yy_doing_yy_more ? yy_more_len : 0) + +/* these variables are all declared out here so that section 3 code can + * manipulate them + */ +/* points to current character in buffer */ +static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr )); +void yyrestart YY_PROTO(( FILE *input_file )); +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); + +#define yy_new_buffer yy_create_buffer + +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif + +YY_DECL + { + register yy_state_type yy_current_state; + register YY_CHAR *yy_cp, *yy_bp; + register int yy_act; + + + if (do_hex) { + BEGIN(HEX); + do_hex = 0; + } + eol_seen = 0; + + + if ( yy_init ) + { + YY_USER_INIT; + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( yy_current_buffer ) + yy_init_buffer( yy_current_buffer, yyin ); + else + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + + yy_init = 0; + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + yy_doing_yy_more = yy_more_flag; + if ( yy_doing_yy_more ) + { + yy_more_len = yyleng; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* support of yytext */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of the + * current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[*yy_cp]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = yy_def[yy_current_state]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_current_state != 184 ); + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + + YY_DO_BEFORE_ACTION; + YY_USER_ACTION; + +do_action: /* this label is used only to access EOF actions */ + + + switch ( yy_act ) + { + case 0: /* must backtrack */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +# line 31 "t2mf.fl" +/* skip whitespace */; + YY_BREAK +case 2: +# line 32 "t2mf.fl" +/* skip comment */ lineno++; + YY_BREAK +case 3: +# line 34 "t2mf.fl" +return MTHD; + YY_BREAK +case 4: +# line 35 "t2mf.fl" +return MTRK; + YY_BREAK +case 5: +# line 36 "t2mf.fl" +return TRKEND; + YY_BREAK +case 6: +# line 38 "t2mf.fl" +return ON; + YY_BREAK +case 7: +# line 39 "t2mf.fl" +return OFF; + YY_BREAK +case 8: +# line 40 "t2mf.fl" +return POPR; + YY_BREAK +case 9: +# line 41 "t2mf.fl" +return PAR; + YY_BREAK +case 10: +# line 42 "t2mf.fl" +return PB; + YY_BREAK +case 11: +# line 43 "t2mf.fl" +return PRCH; + YY_BREAK +case 12: +# line 44 "t2mf.fl" +return CHPR; + YY_BREAK +case 13: +# line 45 "t2mf.fl" +return SYSEX; + YY_BREAK +case 14: +# line 46 "t2mf.fl" +return META; + YY_BREAK +case 15: +# line 47 "t2mf.fl" +return SEQSPEC; + YY_BREAK +case 16: +# line 48 "t2mf.fl" +return TEXT; + YY_BREAK +case 17: +# line 49 "t2mf.fl" +return COPYRIGHT; + YY_BREAK +case 18: +# line 50 "t2mf.fl" +return SEQNAME; + YY_BREAK +case 19: +# line 51 "t2mf.fl" +return INSTRNAME; + YY_BREAK +case 20: +# line 52 "t2mf.fl" +return LYRIC; + YY_BREAK +case 21: +# line 53 "t2mf.fl" +return MARKER; + YY_BREAK +case 22: +# line 54 "t2mf.fl" +return CUE; + YY_BREAK +case 23: +# line 55 "t2mf.fl" +return SEQNR; + YY_BREAK +case 24: +# line 56 "t2mf.fl" +return KEYSIG; + YY_BREAK +case 25: +# line 57 "t2mf.fl" +return TEMPO; + YY_BREAK +case 26: +# line 58 "t2mf.fl" +return TIMESIG; + YY_BREAK +case 27: +# line 59 "t2mf.fl" +return SMPTE; + YY_BREAK +case 28: +# line 60 "t2mf.fl" +return ARB; + YY_BREAK +case 29: +# line 61 "t2mf.fl" +return '/'; + YY_BREAK +case 30: +# line 63 "t2mf.fl" +return MINOR; + YY_BREAK +case 31: +# line 64 "t2mf.fl" +return MAJOR; + YY_BREAK +case 32: +# line 66 "t2mf.fl" +return CH; + YY_BREAK +case 33: +# line 67 "t2mf.fl" +return NOTE; + YY_BREAK +case 34: +# line 68 "t2mf.fl" +return VAL; + YY_BREAK +case 35: +# line 69 "t2mf.fl" +return CON; + YY_BREAK +case 36: +# line 70 "t2mf.fl" +return PROG; + YY_BREAK +case 37: +# line 72 "t2mf.fl" +sscanf (yytext, "%ld", &yyval); return INT; + YY_BREAK +case 38: +# line 73 "t2mf.fl" +sscanf (yytext+2, "%lx", &yyval); return INT; + YY_BREAK +case 39: +# line 74 "t2mf.fl" +yyval = bankno (yytext+1, yyleng-1); return INT; + YY_BREAK +case 40: +# line 75 "t2mf.fl" +sscanf (yytext, "%lx", &yyval); return INT; + YY_BREAK +case 41: +# line 77 "t2mf.fl" +return NOTEVAL; + YY_BREAK +case 42: +# line 79 "t2mf.fl" +BEGIN (QUOTE); + YY_BREAK +case 43: +# line 80 "t2mf.fl" +yymore(); + YY_BREAK +case 44: +# line 81 "t2mf.fl" +BEGIN (0); return STRING; + YY_BREAK +case 45: +# line 82 "t2mf.fl" +yymore(); + YY_BREAK +case 46: +# line 83 "t2mf.fl" +{ error ("unterminated string"); + lineno++; eol_seen++; BEGIN(0); return EOL; + } + YY_BREAK +case YY_STATE_EOF(QUOTE): +# line 86 "t2mf.fl" +error ("EOF in string"); return EOF; + YY_BREAK +case 48: +# line 88 "t2mf.fl" +lineno++; + YY_BREAK +case 49: +# line 89 "t2mf.fl" +lineno++; eol_seen++; BEGIN(0); return EOL; + YY_BREAK +case 50: +# line 91 "t2mf.fl" +BEGIN (0); return ERR; + YY_BREAK +case 51: +# line 92 "t2mf.fl" +BEGIN (0); return ERR; + YY_BREAK +case 52: +# line 93 "t2mf.fl" +return ERR; + YY_BREAK +case 53: +# line 94 "t2mf.fl" +return ERR; + YY_BREAK +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(HEX): +# line 96 "t2mf.fl" +return EOF; + YY_BREAK +case 55: +# line 98 "t2mf.fl" +YY_FATAL_ERROR( "flex scanner jammed" ); + YY_BREAK + + case YY_END_OF_BUFFER: + { + /* amount of text matched not including the EOB char */ + int yy_amount_of_matched_text = yy_cp - yytext - 1; + + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + + /* note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the end- + * of-buffer state). Contrast this with the test in yyinput(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* this was really a NUL */ + { + yy_state_type yy_next_state; + + yy_c_buf_p = yytext + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* okay, we're now positioned to make the + * NUL transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we + * don't want to build jamming into it because + * then it will run more slowly) + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* consume the NUL */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* note: because we've taken care in + * yy_get_next_buffer() to have set up yytext, + * we can now set up yy_c_buf_p so that if some + * total hoser (like flex itself) wants + * to call the scanner after we return the + * YY_NULL, it'll still work - another YY_NULL + * will get returned. + */ + yy_c_buf_p = yytext + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF((yy_start - 1) / 2); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + } + break; + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: +#ifdef FLEX_DEBUG + printf( "action # %d\n", yy_act ); +#endif + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } + } + } + + +/* yy_get_next_buffer - try to read in a new buffer + * + * synopsis + * int yy_get_next_buffer(); + * + * returns a code representing an action + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + + { + register YY_CHAR *dest = yy_current_buffer->yy_ch_buf; + register YY_CHAR *source = yytext - 1; /* copy prev. char, too */ + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + /* try to read more data */ + + /* first move last chars to start of buffer */ + number_to_move = yy_c_buf_p - yytext; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_n_chars = 0; + + else + { + int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1; + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + else if ( num_to_read <= 0 ) + YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); + + /* read in more data */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == 1 ) + { + ret_val = EOB_ACT_END_OF_FILE; + yy_current_buffer->yy_eof_status = EOF_DONE; + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_eof_status = EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + /* yytext begins at the second character in yy_ch_buf; the first + * character is the one which preceded it before reading in the latest + * buffer; it needs to be kept around in case it's a newline, so + * yy_get_previous_state() will have with '^' rules active + */ + + yytext = &yy_current_buffer->yy_ch_buf[1]; + + return ( ret_val ); + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached + * + * synopsis + * yy_state_type yy_get_previous_state(); + */ + +static yy_state_type yy_get_previous_state() + + { + register yy_state_type yy_current_state; + register YY_CHAR *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = yy_def[yy_current_state]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return ( yy_current_state ); + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +register yy_state_type yy_current_state; +#endif + + { + register int yy_is_jam; + register YY_CHAR *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = yy_def[yy_current_state]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 184); + + return ( yy_is_jam ? 0 : yy_current_state ); + } + + +#ifdef YY_USE_PROTOS +static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp ) +#else +static void yyunput( c, yy_bp ) +YY_CHAR c; +register YY_CHAR *yy_bp; +#endif + + { + register YY_CHAR *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */ + register YY_CHAR *dest = + &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2]; + register YY_CHAR *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += dest - source; + yy_bp += dest - source; + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + if ( yy_cp > yy_bp && yy_cp[-1] == '\n' ) + yy_cp[-2] = '\n'; + + *--yy_cp = c; + + /* note: the formal parameter *must* be called "yy_bp" for this + * macro to now work correctly + */ + YY_DO_BEFORE_ACTION; /* set up yytext again */ + } + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + + { + int c; + YY_CHAR *yy_cp = yy_c_buf_p; + + *yy_cp = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* this was really a NUL */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + yytext = yy_c_buf_p; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + { + yy_c_buf_p = yytext + YY_MORE_ADJ; + return ( EOF ); + } + + YY_NEW_FILE; + +#ifdef __cplusplus + return ( yyinput() ); +#else + return ( input() ); +#endif + } + break; + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext + YY_MORE_ADJ; + break; + + case EOB_ACT_LAST_MATCH: +#ifdef __cplusplus + YY_FATAL_ERROR( "unexpected last match in yyinput()" ); +#else + YY_FATAL_ERROR( "unexpected last match in input()" ); +#endif + } + } + } + + c = *yy_c_buf_p; + yy_hold_char = *++yy_c_buf_p; + + return ( c ); + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + + { + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* flush out information for old buffer */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* we don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) ); + + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) ); + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + yy_init_buffer( b, file ); + + return ( b ); + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + free( (char *) b->yy_ch_buf ); + free( (char *) b ); + } + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + { + b->yy_input_file = file; + + /* we put in the '\n' and start reading from [1] so that an + * initial match-at-newline will be true. + */ + + b->yy_ch_buf[0] = '\n'; + b->yy_n_chars = 1; + + /* we always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[1]; + + b->yy_eof_status = EOF_NOT_SEEN; + } +# line 98 "t2mf.fl" + diff --git a/tools/midicomp-0.0.4/yyread.c b/tools/midicomp-0.0.4/yyread.c new file mode 100644 index 0000000..bd39d7b --- /dev/null +++ b/tools/midicomp-0.0.4/yyread.c @@ -0,0 +1,39 @@ +/* $Id: yyread.c,v 1.2 1991/11/03 21:53:20 piet Rel $ */ +/* sozobon version */ + +#include +#include + +/* + * read, ignoring CR's + * + * ++jrb + */ +int _yyread(fd, buf, size) +int fd; char *buf; int size; +{ + int count = read(fd, buf, size); + int done = 0, i; + + if(count <= 0) + return count; + + do{ + for(i = done; i < (done+count); i++) + { + if(buf[i] == '\r') + { + if(i < done + count - 1) + bcopy(&buf[i+1], &buf[i], (count -1 - (i - done))); + count -= 1; + } + } + done += count; + if(done == size) + return done; + count = read(fd, &buf[done], (size - done)); + } while(count > 0); + + return done; +} +