A0		midi2ps.c	/^#define A0 21			\/* lowest A on piano *\// ;" macro 1 { PSdrawNotes }	{ }
AmpBoost		play.c	/^int AmpBoost = 0;/ ;" global 1 { Mplay getNextByte play }	{ }
AmpScale		play.c	/^float AmpScale = 1.00;/ ;" global 1 { Mplay getNextByte play }	{ }
Ascale		filter.c	/^float Ascale = 1.0;/ ;" global 1 { Mfilter amp }	{ }
Case		argv.h	/^#define Case break; case/ ;" macro 1 { E Mfilter Mmidi2ps Mplay Pcommands exception filter mlReadEvent play ptoi }	{ }
Channel		filter.c	/^int Channel = -1;/ ;" global 1 { Mfilter Mplay filter getNextByte }	{ }
Color		midi2ps.c	/^typedef struct { float r,g,b; } Color;/ ;" typedef 1 { }	{ }
CtrlGray		midi2ps.c	/^int	CtrlGray = 0;	\/* draw control tracks as gray s/ ;" global 1 { Mmidi2ps PSdrawNotes }	{ }
DEFAULTDIVISION		midifile.c	/^#define DEFAULTDIVISION 1024/ ;" macro 1 { MIDIFILEBeginWriting }	{ }
DEFAULTTEMPO		midifile.c	/^#define DEFAULTTEMPO (120.0)/ ;" macro 1 { MIDIFILEBeginReading MIDIFILEBeginWriting mlReadPreamble }	{ }
Default		argv.h	/^#define Default break; default/ ;" macro 1 { E Mda Mfilter Mmidi2ps Mmpu Mplay Pcommands }	{ }
DrawBorder		midi2ps.c	/^int	DrawBorder = 1;	\/* do -g 0 if you want all-bla/ ;" global 1 { Mmidi2ps PSputHeader }	{ }
E		filter.c	/^#define E error/ ;" macro 1 { Mmpu Mra allNotesOff allocPort createPortSet filter interrupt midiDriverInit mlReadEvent mlSetPointers play sendData setFile use }	{ error }
Event		mpu.c	/^typedef struct {/ ;" typedef 5 { Mmpu Mra }	{ }
FileName		midi2ps.c	/^char	*FileName = "";/ ;" global 1 { PSputHeader midi2ps }	{ }
Font		midi2ps.c	/^char	*Font = "Univers-Condensed";/ ;" global 1 { Mmidi2ps PSputHeader use }	{ }
IF		ra.c	/^#define IF(x) if (strncmp(t+2,x,strlen(x))==0)/ ;" macro 1 { Mra }	{ }
IP		midifile.c	/^#define IP ((MIDIFILEInStruct *)p)/ ;" macro 1 { MIDIFILEEndReading MIDIFILEReadEvent MIDIFILEReadPreamble MIDIFILESetReadQuantaSize }	{ MIDIFILEInStruct }
Inch		midi2ps.c	/^Point Inch = {72,72};	\/* 72 points per inch *\// ;" global 1 { PSputHeader }	{ }
KEYSIG		midifile.c	/^#define KEYSIG 0x59/ ;" macro 1 { MIDIFILEWriteSig readMetaevent }	{ }
M		midilist.c	/^#define M m->m[m->n]/ ;" macro 1 { Mmpu Mra PSputHeader filter getNextByte mlReadEvent ml_addCommand play }	{ }
METAEVENT		midifile.c	/^#define METAEVENT(_x) (0xff00 | _x)/ ;" macro 1 { MIDIFILEEndWritingTrack MIDIFILEWriteSMPTEoffset MIDIFILEWriteSequenceNumber MIDIFILEWriteSig MIDIFILEWriteTempo MIDIFILEWriteText }	{ }
MIDIFILEBeginReading		midifile.c	/^void *MIDIFILEBeginReading(NXStream *s,MIDIFILERea/ ;" function 20 { }	{ DEFAULTTEMPO MIDIFILEInStruct MIDIFILE_DEFAULTQUANTASIZE tempo }
MIDIFILEBeginWriting		midifile.c	/^void *MIDIFILEBeginWriting(NXStream *s, int level,/ ;" function 23 { Mmpu Mra filter }	{ DEFAULTDIVISION DEFAULTTEMPO MIDIFILEBeginWritingTrack MIDIFILEOutStruct MIDIFILE_DEFAULTQUANTASIZE NULL OP tempo writeChunkType writeLong writeShort }
MIDIFILEBeginWritingTrack		midifile.c	/^int MIDIFILEBeginWritingTrack(void *p, char *track/ ;" function 23 { MIDIFILEBeginWriting Mmpu Mra filter }	{ MIDIFILEEndWritingTrack OP writeByte writeBytes writeChunkType writeLong writeVariableQuantity }
MIDIFILEEndReading		midifile.c	/^void *MIDIFILEEndReading(void *p)/ ;" function 6 { }	{ IP NULL }
MIDIFILEEndWriting		midifile.c	/^int MIDIFILEEndWriting(void *p)/ ;" function 19 { Mmpu Mra filter }	{ MIDIFILEEndWritingTrack OP }
MIDIFILEEndWritingTrack		midifile.c	/^int MIDIFILEEndWritingTrack(void *p,int quanta)/ ;" function 17 { MIDIFILEBeginWritingTrack MIDIFILEEndWriting Mmpu Mra filter }	{ METAEVENT OP TRACKCHANGE writeByte writeShort writeTime }
MIDIFILEInStruct		midifile.c	/^typedef struct _MIDIFILEInStruct {  \/* Private str/ ;" typedef 13 { IP MIDIFILEBeginReading SCALEQUANTA }	{ }
MIDIFILEMetaevent		midifile.h	/^typedef enum _MIDIFILEMetaEvent {/ ;" typedef 38 { }	{ }
MIDIFILEOutStruct		midifile.c	/^typedef struct _MIDIFILEOutStruct {/ ;" typedef 10 { MIDIFILEBeginWriting OP }	{ }
MIDIFILEReadEvent		midifile.c	/^int MIDIFILEReadEvent(register void *p)/ ;" function 68 { }	{ IP NO SCALEQUANTA YES readEscapeEvent readMetaevent readSysExclEvent readTrackHeader readVariableQuantity }
MIDIFILEReadPreamble		midifile.c	/^int MIDIFILEReadPreamble(void *p,int *level,int *t/ ;" function 34 { }	{ IP readChunkType readLong readShort }
MIDIFILEReadStruct		midifile.h	/^typedef struct _MIDIFILEReadStruct {/ ;" typedef 6 { }	{ }
MIDIFILESetReadQuantaSize		midifile.c	/^int MIDIFILESetReadQuantaSize(void *p,int usec)/ ;" function 9 { }	{ IP tempo }
MIDIFILEWriteEvent		midifile.c	/^int MIDIFILEWriteEvent(register void *p,int quanta/ ;" function 13 { Mmpu Mra filter }	{ writeByte writeBytes writeTime writeVariableQuantity }
MIDIFILEWriteSMPTEoffset		midifile.c	/^int MIDIFILEWriteSMPTEoffset(void *p,unsigned char/ ;" function 11 { }	{ METAEVENT SMPTEOFFSET writeByte writeShort }
MIDIFILEWriteSequenceNumber		midifile.c	/^int MIDIFILEWriteSequenceNumber(void *p,int data)/ ;" function 8 { }	{ METAEVENT SEQUENCENUMBER writeByte writeShort }
MIDIFILEWriteSig		midifile.c	/^int MIDIFILEWriteSig(void *p,int quanta,short meta/ ;" function 10 { }	{ KEYSIG METAEVENT TIMESIG writeByte writeLong writeShort writeTime }
MIDIFILEWriteSysExcl		midifile.c	/^int MIDIFILEWriteSysExcl(void *p,int quanta,int nD/ ;" function 9 { }	{ writeByte writeBytes writeTime writeVariableQuantity }
MIDIFILEWriteTempo		midifile.c	/^int MIDIFILEWriteTempo(void *p,int quanta, int bea/ ;" function 13 { Mmpu Mra filter }	{ METAEVENT OP TEMPOCHANGE tempo writeLong writeShort writeTime }
MIDIFILEWriteText		midifile.c	/^int MIDIFILEWriteText(void *p,int quanta,short met/ ;" function 12 { }	{ METAEVENT writeBytes writeShort writeTime writeVariableQuantity }
MIDIFILE_DEFAULTQUANTASIZE		midifile.h	/^#define MIDIFILE_DEFAULTQUANTASIZE (1000)/ ;" macro 1 { MIDIFILEBeginReading MIDIFILEBeginWriting mlReadPreamble }	{ }
Margin		midi2ps.c	/^      Margin = {.25,.25},/ ;" global 1 { Mmidi2ps PSputHeader use }	{ }
MaxDuration		midi2ps.c	/^float	MaxDuration = 0;\/* scale horizontal length t/ ;" global 1 { Mmidi2ps PSputHeader }	{ }
MaxEvents		play.c	/^#define MaxEvents (MaxNotes+6)/ ;" macro 1 { allNotesOff }	{ MaxNotes }
MaxLen		midi2ps.c	/^#define MaxLen 7/ ;" macro 1 { }	{ }
MaxLength		midi2ps.c	/^float	MaxLength = MaxLen;/ ;" global 1 { Mmidi2ps }	{ }
MaxNotes		midi2ps.c	/^#define MaxNotes 128/ ;" macro 1 { MaxEvents PSdrawNotes allNotesOff }	{ }
Mda		da.c	/^main(ac,av) char *av[]; {/ ;" function 10 { }	{ Default MidiList NULL NotesOnly da for_each_argument use }
Mfilter		filter.c	/^main(ac,av) char *av[]; {/ ;" function 16 { }	{ Ascale Case Channel Default MidiList NULL NotesOnly Transpose Tscale argument dofile for_each_argument use }
MidiCmd		midilist.h	/^typedef struct {/ ;" typedef 6 { Pcommands filter mlAlloc }	{ }
MidiList		midilist.h	/^typedef struct {/ ;" typedef 19 { Mda Mfilter Mmidi2ps }	{ }
MinGray		midi2ps.c	/^float	MinGray = .5;	\/* do -g 0 if you want all-bla/ ;" global 1 { Mmidi2ps PSdrawNotes use }	{ }
Mmidi2ps		midi2ps.c	/^main(ac,av) char *av[]; {/ ;" function 26 { }	{ Case CtrlGray Default DrawBorder Font Margin MaxDuration MaxLength MidiList MinGray NULL NotesOnly Size argument backGround bf for_each_argument midi2ps paleYellow s2t use }
Mmpu		mpu.c	/^main(int ac, char **av){/ ;" function 55 { }	{ Default E Event M MIDIFILEBeginWriting MIDIFILEBeginWritingTrack MIDIFILEEndWriting MIDIFILEEndWritingTrack MIDIFILEWriteEvent MIDIFILEWriteTempo NULL argument for_each_argument nextchar play use }
Mplay		play.c	/^main(int ac, char **av){/ ;" function 39 { }	{ AmpBoost AmpScale Case Channel Default Playing PrintTimes Transpose argument error for_each_argument midiDriverInit play setFile synchToTimeCode synchUnit tempo unit use whichUnit }
Mra		ra.c	/^main(int ac, char **av){/ ;" function 50 { }	{ E Event IF M MIDIFILEBeginWriting MIDIFILEBeginWritingTrack MIDIFILEEndWriting MIDIFILEEndWritingTrack MIDIFILEWriteEvent MIDIFILEWriteTempo NULL nop pitch ptoi setData tempo }
N		play.c	/^int N = 0;/ ;" global 1 { getNextByte play setFile }	{ }
NO		midilist.c	/^#define NO  0/ ;" macro 1 { MIDIFILEReadEvent mlReadEvent }	{ }
NULL		midilist.c	/^#define NULL (void *)0/ ;" macro 1 { MIDIFILEBeginWriting MIDIFILEEndReading Mda Mfilter Mmidi2ps Mmpu Mra PSputHeader fdWaitInput filter }	{ }
NoteRange		midi2ps.c	/^int	NoteRange = 100;\/* 12 lines for control tracks/ ;" global 1 { PSdrawNotes PSputHeader }	{ }
NotesOnly		da.c	/^int NotesOnly = 0;/ ;" global 1 { Mda Mfilter Mmidi2ps PSdrawNotes Pcommands filter }	{ }
OP		midifile.c	/^#define OP ((MIDIFILEOutStruct *)p)/ ;" macro 1 { MIDIFILEBeginWriting MIDIFILEBeginWritingTrack MIDIFILEEndWriting MIDIFILEEndWritingTrack MIDIFILEWriteTempo writeBytes writeTime }	{ MIDIFILEOutStruct }
Origin		midi2ps.c	/^Point Origin = {0.,0.},/ ;" global 1 { PSputHeader }	{ }
P		da.c	/^P(a,b,c,d,e,f) int a,b,c,d,e,f; { printf((char *)a/ ;" function 1 { PSdrawNotes PSputHeader PSputTrailer Pcommands }	{ }
PSdrawNotes		midi2ps.c	/^void PSdrawNotes(FILE *f, MidiList *m){ \/* draw PS/ ;" function 57 { midi2ps }	{ A0 CtrlGray MaxNotes MinGray NoteRange NotesOnly P Point T controlOffset controlPos isControl isNoteOff isNoteOn muldiv uchar }
PSputHeader		midi2ps.c	/^void PSputHeader(FILE *f, MidiList *M){/ ;" function 52 { midi2ps }	{ DrawBorder FileName Font Inch M Margin MaxDuration NULL NoteRange Origin P Point Size add backGround bold mul oblique rgb t2s }
PSputTrailer		midi2ps.c	/^void PSputTrailer(FILE *f){/ ;" function 3 { midi2ps }	{ P }
Pcommands		da.c	/^Pcommands(MidiList *m){/ ;" function 52 { da }	{ Case Default MidiCmd NotesOnly P T hex ptos t2s uchar }
Pheader		da.c	/^Pheader(char *file, MidiList *m){/ ;" function 4 { da }	{ t2s tempo }
Playing		play.c	/^int Playing = 0;/ ;" global 1 { Mplay getNextByte play setFile }	{ }
Point		midi2ps.c	/^typedef struct { float x, y; } Point;/ ;" typedef 1 { PSdrawNotes PSputHeader }	{ }
PrintTimes		play.c	/^int PrintTimes = 0;/ ;" global 1 { Mplay play }	{ }
Qscale		play.c	/^#define Qscale (60.0\/(float)(tempo))/ ;" macro 1 { play }	{ tempo }
RGB		midi2ps.c	/^#define RGB(r,g,b)	bf(r),bf(g),bf(b)/ ;" macro 1 { }	{ bf }
SCALEQUANTA		midifile.c	/^#define SCALEQUANTA(_p,quanta) \\/ ;" macro 1 { MIDIFILEReadEvent mlReadEvent }	{ MIDIFILEInStruct }
SEQUENCENUMBER		midifile.c	/^#define SEQUENCENUMBER 0/ ;" macro 1 { MIDIFILEWriteSequenceNumber readMetaevent }	{ }
SMPTEOFFSET		midifile.c	/^#define SMPTEOFFSET 0x54/ ;" macro 1 { MIDIFILEWriteSMPTEoffset readMetaevent }	{ }
Size		midi2ps.c	/^      Size = {MaxLen,1.5};	\/* default size of the / ;" global 1 { Mmidi2ps PSputHeader use }	{ }
T		da.c	/^#define T(x) ((float)(x)\/(float)m->quantaSize)/ ;" macro 1 { PSdrawNotes Pcommands mlSetPointers }	{ }
TEMPOCHANGE		midifile.c	/^#define TEMPOCHANGE 0x51/ ;" macro 1 { MIDIFILEWriteTempo readMetaevent }	{ }
TIMESIG		midifile.c	/^#define TIMESIG 0x58/ ;" macro 1 { MIDIFILEWriteSig readMetaevent }	{ }
TRACKCHANGE		midifile.c	/^#define TRACKCHANGE 0x2f/ ;" macro 1 { MIDIFILEEndWritingTrack readMetaevent }	{ }
Time		filter.c	/^#define Time(t) (int)((float)(t)*Tscale)/ ;" macro 1 { filter }	{ Tscale }
Transpose		filter.c	/^int Transpose = 0;/ ;" global 1 { Mfilter Mplay getNextByte pitch play }	{ }
Tscale		filter.c	/^float Tscale = 1.0;/ ;" global 1 { Mfilter Time }	{ }
YES		midilist.c	/^#define YES 1/ ;" macro 1 { MIDIFILEReadEvent mlReadEvent }	{ }
_MIDIFILEInStruct		midifile.c	/^typedef struct _MIDIFILEInStruct {  \/* Private str/ ;" struct 13 { }	{ }
_MIDIFILEMetaEvent		midilist.h	/^typedef enum _MIDIFILEMetaEvent {/ ;" struct 38 { }	{ }
_MIDIFILEOutStruct		midifile.c	/^typedef struct _MIDIFILEOutStruct {/ ;" struct 10 { }	{ }
_MIDIFILEReadStruct		midifile.h	/^typedef struct _MIDIFILEReadStruct {/ ;" struct 6 { }	{ }
_arg		argv.h	/^static char *_arg, *_argp; \/* use by 'for_each_arg/ ;" global 1 { argument }	{ }
_argp		argv.h	/^static char *_arg, *_argp; \/* use by 'for_each_arg/ ;" global 1 { argument for_each_argument }	{ }
add		midi2ps.c	/^Point add(a,b) Point a,b; { return b.x += a.x, b.y/ ;" function 1 { PSputHeader }	{ }
allNotesOff		play.c	/^static void allNotesOff(void) {/ ;" function 56 { interrupt play setFile }	{ E MaxEvents MaxNotes driverPort funcs maxQueueSize ownerPort ports queuePort unit }
allRead		play.c	/^static boolean_t allRead;    \/* Flag signaling all/ ;" global 1 { queueReply }	{ }
allSent		play.c	/^static boolean_t allSent;    \/* Flag signaling all/ ;" global 1 { queueReply }	{ }
allocPort		play.c	/^static port_t allocPort(){/ ;" function 5 { midiDriverInit }	{ E }
amp		filter.c	/^#define amp(p) (unsigned char)(p?(((float)(p)*Asca/ ;" macro 1 { filter }	{ Ascale }
argument		argv.h	/^#define argument  (_arg=(*_argp? _argp : av[++i==a/ ;" macro 1 { Mfilter Mmidi2ps Mmpu Mplay }	{ _arg _argp }
av0		argv.h	/^static char *av0;       \/* will hold name of the c/ ;" global 1 { for_each_argument midi2ps use }	{ }
backGround		midi2ps.c	/^Color backGround = {0,0,0};/ ;" global 1 { Mmidi2ps PSputHeader }	{ }
bf		midi2ps.c	/^#define bf(x)		((float)(x)\/256.)/ ;" macro 1 { Mmidi2ps RGB }	{ }
bold		midi2ps.c	/^char *bold(char *s)   { return face(s,"Bold"); }/ ;" function 1 { PSputHeader }	{ face }
byteIndex		play.c	/^static int byteIndex = 0;/ ;" global 1 { getNextByte play putE sendData }	{ }
checkRealloc		midifile.c	/^static void checkRealloc(MIDIFILEInStruct *p,int n/ ;" function 6 { readEscapeEvent readMetaevent readSysExclEvent }	{ }
controlOffset		midi2ps.c	/^#define controlOffset 12	\/* leave room for control/ ;" macro 1 { PSdrawNotes }	{ }
controlPos		midi2ps.c	/^#define controlPos(x)   (x == 64? 0 : 2)/ ;" macro 1 { PSdrawNotes }	{ }
createPortSet		play.c	/^static port_t createPortSet(port_t queuePort, port/ ;" function 7 { midiDriverInit }	{ E exceptionPort queuePort }
da		da.c	/^da(char *file, MidiList *m){/ ;" function 6 { Mda }	{ Pcommands Pheader mlRead }
docmd		play.c	/^docmd(){/ ;" function 3 { }	{ }
dofile		filter.c	/^dofile(char *file, MidiList *m){/ ;" function 5 { Mfilter }	{ filter mlRead }
driverPort		play.c	/^static port_t driverPort;    \/* Port for driver on/ ;" global 1 { allNotesOff interrupt midiDriverInit play sendData setFile }	{ }
error		play.c	/^static error(fmt,a,b,c,d) char *fmt; int a,b,c,d; / ;" function 3 { E Mplay exception midi2ps play sendData use }	{ }
events		play.c	/^static MIDIRawEvent events[MIDI_MAX_EVENT];/ ;" global 1 { getNextByte play putE sendData }	{ }
exception		play.c	/^static void exception(port_t replyPort, int e){/ ;" function 9 { }	{ Case error }
exceptionPort		play.c	/^static port_t exceptionPort; \/* Port for timing ex/ ;" global 1 { createPortSet midiDriverInit }	{ }
face		midi2ps.c	/^char *face(char *s,char *f){/ ;" function 9 { bold oblique }	{ suf }
fdSize		midilist.c	/^int fdSize(int f){ \/* return size of file 'f' *\// ;" function 5 { mlRead }	{ }
fdWaitInput		play.c	/^int fdWaitInput(int fd, int timeout)/ ;" function 11 { play }	{ NULL }
filter		filter.c	/^filter(MidiList *m){/ ;" function 55 { dofile }	{ Case Channel E M MIDIFILEBeginWriting MIDIFILEBeginWritingTrack MIDIFILEEndWriting MIDIFILEEndWritingTrack MIDIFILEWriteEvent MIDIFILEWriteTempo MidiCmd NULL NotesOnly Time amp pitch uchar }
for_each_argument		argv.h	/^#define for_each_argument av0 = av[0]; for (i=1;i</ ;" macro 1 { Mda Mfilter Mmidi2ps Mmpu Mplay }	{ _argp av0 }
funcs		play.c	/^static MIDIReplyFunctions funcs = {0};/ ;" global 1 { allNotesOff }	{ }
getNextByte		play.c	/^static int getNextByte(){/ ;" function 38 { play queueReply }	{ AmpBoost AmpScale Channel M N Playing Transpose byteIndex events }
hex		util.c	/^char *hex(unsigned char *s, int n){/ ;" function 9 { Pcommands }	{ }
interrupt		play.c	/^static void interrupt() {/ ;" function 6 { midiDriverInit }	{ E allNotesOff driverPort ownerPort }
isControl		midi2ps.c	/^#define isControl(c)	((c[0]&0xf0)==0xb0)/ ;" macro 1 { PSdrawNotes }	{ }
isNoteOff		midi2ps.c	/^#define isNoteOff(c)	(((c[0]&0xf0)==0x90 && c[2]==/ ;" macro 1 { PSdrawNotes }	{ }
isNoteOn		midi2ps.c	/^#define isNoteOn(c)	((c[0]&0xf0)==0x90 && c[2]>0)/ ;" macro 1 { PSdrawNotes }	{ }
main		da.c	/^main(ac,av) char *av[]; {/ ;" function 10 { }	{ Default MidiList NULL NotesOnly da for_each_argument use }
maxQueueSize		play.c	/^static int maxQueueSize;     \/* Maximum output que/ ;" global 1 { allNotesOff midiDriverInit play }	{ }
midi2ps		midi2ps.c	/^void midi2ps(FILE *out, char *file, MidiList *m){/ ;" function 8 { Mmidi2ps }	{ FileName PSdrawNotes PSputHeader PSputTrailer av0 error mlRead }
midiDriverInit		play.c	/^midiDriverInit(){    \/* Set up MIDI driver *\// ;" function 15 { Mplay }	{ E allocPort createPortSet driverPort exceptionPort interrupt maxQueueSize ownerPort ports queuePort synchToTimeCode synchUnit unit }
mlAlloc		midilist.c	/^static void mlAlloc(MidiList *m, int n){/ ;" function 8 { mlRead }	{ MidiCmd uchar }
mlRead		midilist.c	/^int mlRead(char *file, MidiList *m){/ ;" function 11 { da dofile midi2ps play }	{ fdSize mlAlloc mlSetPointers }
mlReadEvent		midilist.c	/^static int mlReadEvent(MidiList *m){ \/* return 0 a/ ;" function 53 { mlSetPointers }	{ Case E M NO SCALEQUANTA YES ml_getc readEscapeEvent readMetaevent readSysExclEvent readTrackHeader readVariableQuantity }
mlReadPreamble		midilist.c	/^static int mlReadPreamble(MidiList *m){/ ;" function 38 { mlSetPointers }	{ DEFAULTTEMPO MIDIFILE_DEFAULTQUANTASIZE mlSetReadQuantaSize ml_get ml_incr tempo }
mlSetPointers		midilist.c	/^static void mlSetPointers(MidiList *m){/ ;" function 9 { mlRead }	{ E T mlReadEvent mlReadPreamble }
mlSetReadQuantaSize		midilist.c	/^static int mlSetReadQuantaSize(MidiList *m, int us/ ;" function 8 { mlReadPreamble }	{ tempo }
ml_addCommand		midilist.c	/^#define ml_addCommand(m,len) M.s = m->d; M.n = len/ ;" macro 1 { readMetaevent }	{ M }
ml_get		midilist.c	/^#define ml_get(m,n)  bcopy(m->p,&n,sizeof(n)); ml_/ ;" macro 1 { mlReadPreamble readMetaevent readTrackHeader }	{ ml_incr }
ml_getc		midilist.c	/^#define ml_getc(m,c) (c = m->p[0], m->p++, m->p<m-/ ;" macro 1 { mlReadEvent readMetaevent readVariableQuantity }	{ }
ml_incr		midilist.c	/^#define ml_incr(m,n) if ((m->p += n) >= m->p_end) / ;" macro 1 { mlReadPreamble ml_get readTrackHeader }	{ }
mul		midi2ps.c	/^Point mul(a,b) Point a,b; { return b.x *= a.x, b.y/ ;" function 1 { PSputHeader }	{ }
muldiv		midi2ps.c	/^#define muldiv(a,b,c)	((double)(a)*(double)(b)\/(do/ ;" macro 1 { PSdrawNotes }	{ }
nextchar		mpu.c	/^#define nextchar(c) if ((c=getc(f))==255) goto Out/ ;" macro 1 { Mmpu }	{ }
nop		ra.c	/^nop(){}/ ;" function 1 { Mra }	{ }
oblique		midi2ps.c	/^char *oblique(char *s){ return face(s,"Oblique"); / ;" function 1 { PSputHeader }	{ face }
ownerPort		play.c	/^static port_t ownerPort;     \/* Port that represen/ ;" global 1 { allNotesOff interrupt midiDriverInit play sendData setFile }	{ }
paleYellow		midi2ps.c	/^Color paleYellow = {RGB(255,250,200)};/ ;" global 1 { Mmidi2ps }	{ }
pitch		filter.c	/^#define pitch(p) (unsigned char)((p)+Transpose)/ ;" macro 1 { Mra filter ptoi }	{ Transpose }
play		play.c	/^int play(char *file){/ ;" function 94 { Mmpu Mplay }	{ AmpBoost AmpScale Case E M N Playing PrintTimes Qscale Transpose allNotesOff byteIndex driverPort error events fdWaitInput getNextByte maxQueueSize mlRead ownerPort queuePort setFile synchToTimeCode tempo unit }
ports		play.c	/^static port_set_name_t ports;\/* Port set to listen/ ;" global 1 { allNotesOff midiDriverInit }	{ }
ptoi		util.c	/^ptoi(char *s)/ ;" function 30 { Mra }	{ Case pitch }
ptos		util.c	/^ptos(char key)/ ;" function 12 { Pcommands }	{ }
putE		play.c	/^putE(){/ ;" function 6 { }	{ byteIndex events }
queuePort		play.c	/^static port_t queuePort;     \/* Port for output qu/ ;" global 1 { allNotesOff createPortSet midiDriverInit play sendData }	{ }
queueReply		play.c	/^static void queueReply(port_t replyPort, short uni/ ;" function 7 { }	{ allRead allSent getNextByte sendData }
readBytes		midifile.c	/^static int readBytes(NXStream *s, unsigned char *b/ ;" function 5 { readEscapeEvent readMetaevent readSysExclEvent }	{ }
readChunkType		midifile.c	/^static int readChunkType(NXStream *s,char *buf)/ ;" function 6 { MIDIFILEReadPreamble readTrackHeader }	{ }
readEscapeEvent		midifile.c	/^static int readEscapeEvent(MIDIFILEInStruct *p)/ ;" function 7 { MIDIFILEReadEvent mlReadEvent }	{ checkRealloc readBytes readVariableQuantity }
readLong		midifile.c	/^static int readLong(NXStream *s, int *n)/ ;" function 5 { MIDIFILEReadPreamble readTrackHeader }	{ }
readMetaevent		midifile.c	/^static int readMetaevent(MIDIFILEInStruct *p)/ ;" function 90 { MIDIFILEReadEvent mlReadEvent }	{ KEYSIG SEQUENCENUMBER SMPTEOFFSET TEMPOCHANGE TIMESIG TRACKCHANGE checkRealloc readBytes readShort readTrackHeader readVariableQuantity tempo }
readShort		midifile.c	/^static int readShort(NXStream *s, short *n)/ ;" function 5 { MIDIFILEReadPreamble readMetaevent }	{ }
readSysExclEvent		midifile.c	/^static int readSysExclEvent(MIDIFILEInStruct *p,in/ ;" function 22 { MIDIFILEReadEvent mlReadEvent }	{ checkRealloc readBytes readVariableQuantity }
readTrackHeader		midifile.c	/^static int readTrackHeader(MIDIFILEInStruct *p)/ ;" function 14 { MIDIFILEReadEvent mlReadEvent readMetaevent }	{ readChunkType readLong }
readVariableQuantity		midifile.c	/^static int readVariableQuantity(NXStream *s, int */ ;" function 14 { MIDIFILEReadEvent mlReadEvent readEscapeEvent readMetaevent readSysExclEvent }	{ }
rgb		midi2ps.c	/^#define rgb(c)		c.r,c.g,c.b/ ;" macro 1 { PSputHeader }	{ }
s2t		util.c	/^float s2t(char *s){/ ;" function 9 { Mmidi2ps }	{ }
sendData		play.c	/^static int sendData(void){/ ;" function 15 { queueReply }	{ E byteIndex driverPort error events ownerPort queuePort unit }
setData		ra.c	/^setData(Event *e, char *s){/ ;" function 7 { Mra }	{ xval }
setFile		play.c	/^char *setFile(char *s){/ ;" function 9 { Mplay play }	{ E N Playing allNotesOff driverPort ownerPort }
someSent		play.c	/^static boolean_t someSent;   \/* Flag signaling if / ;" global 1 { }	{ }
sub		midi2ps.c	/^Point sub(a,b) Point a,b; { return a.x -= b.x, a.y/ ;" function 1 { }	{ }
suf		midi2ps.c	/^#define suf(p) if (tailmatch(n,p)) n[strlen(n)-str/ ;" macro 1 { face }	{ tailmatch }
synchToTimeCode		play.c	/^static int synchToTimeCode = FALSE;/ ;" global 1 { Mplay midiDriverInit play }	{ }
synchUnit		play.c	/^static int synchUnit;           \/* Serial port to / ;" global 1 { Mplay midiDriverInit }	{ }
t2s		util.c	/^char *t2s(float t){/ ;" function 7 { PSputHeader Pcommands Pheader }	{ }
tailmatch		midi2ps.c	/^int tailmatch(s,t) char *s, *t; {/ ;" function 3 { suf }	{ }
tempo		play.c	/^static int tempo = 60;/ ;" global 1 { MIDIFILEBeginReading MIDIFILEBeginWriting MIDIFILESetReadQuantaSize MIDIFILEWriteTempo Mplay Mra Pheader Qscale mlReadPreamble mlSetReadQuantaSize play readMetaevent }	{ }
uchar		midilist.h	/^#define uchar unsigned char/ ;" macro 1 { PSdrawNotes Pcommands filter mlAlloc }	{ }
unit		play.c	/^static int unit = MIDI_PORT_A_UNIT; \/* Serial port/ ;" global 1 { Mplay allNotesOff midiDriverInit play sendData }	{ }
use		da.c	/^use(){/ ;" function 5 { Mda Mfilter Mmidi2ps Mmpu Mplay }	{ av0 error }
whichUnit		play.c	/^int whichUnit(char *s){/ ;" function 3 { Mplay }	{ }
writeByte		midifile.c	/^static int writeByte(MIDIFILEOutStruct *p, unsigne/ ;" function 6 { MIDIFILEBeginWritingTrack MIDIFILEEndWritingTrack MIDIFILEWriteEvent MIDIFILEWriteSMPTEoffset MIDIFILEWriteSequenceNumber MIDIFILEWriteSig MIDIFILEWriteSysExcl writeVariableQuantity }	{ }
writeBytes		midifile.c	/^static int writeBytes(MIDIFILEOutStruct *p, unsign/ ;" function 9 { MIDIFILEBeginWritingTrack MIDIFILEWriteEvent MIDIFILEWriteSysExcl MIDIFILEWriteText }	{ OP }
writeChunkType		midifile.c	/^static int writeChunkType(MIDIFILEOutStruct *p, ch/ ;" function 6 { MIDIFILEBeginWriting MIDIFILEBeginWritingTrack }	{ }
writeLong		midifile.c	/^static int writeLong(MIDIFILEOutStruct *p, int n)/ ;" function 6 { MIDIFILEBeginWriting MIDIFILEBeginWritingTrack MIDIFILEWriteSig MIDIFILEWriteTempo }	{ }
writeShort		midifile.c	/^static int writeShort(MIDIFILEOutStruct *p, short / ;" function 6 { MIDIFILEBeginWriting MIDIFILEEndWritingTrack MIDIFILEWriteSMPTEoffset MIDIFILEWriteSequenceNumber MIDIFILEWriteSig MIDIFILEWriteTempo MIDIFILEWriteText }	{ }
writeTime		midifile.c	/^static int writeTime(MIDIFILEOutStruct *p, int qua/ ;" function 9 { MIDIFILEEndWritingTrack MIDIFILEWriteEvent MIDIFILEWriteSig MIDIFILEWriteSysExcl MIDIFILEWriteTempo MIDIFILEWriteText }	{ OP writeVariableQuantity }
writeVariableQuantity		midifile.c	/^static int writeVariableQuantity(MIDIFILEOutStruct/ ;" function 9 { MIDIFILEBeginWritingTrack MIDIFILEWriteEvent MIDIFILEWriteSysExcl MIDIFILEWriteText writeTime }	{ writeByte }
xval		ra.c	/^#define xval(c) (isdigit(c)? (c-'0') : ((c-'a')+10/ ;" macro 1 { setData }	{ }
