DIRECTORY
Beam USING [GetHeapIndex, Length, SetSyncs],
Chord USING [GetHeapIndex, Length],
MusicDefs,
MusicFileDefs,
Note USING [GetSyncIndex],
Piece USING [MaxToc],
Score USING [FileStats, Look, SetKey, SetMetrenome, Test],
Sheet USING [Reset, SetBegin],
StreamDefs USING [Append, DiskHandle, NewWordStream, Read, ReadBlock, WriteBlock, Write],
Sync USING [AddTimes, GetScoreIndex, Length],
Utility USING [InitStorage, NewBeam, NewChord, NewNote, NewSync];

FilerImpl: CEDAR PROGRAM
IMPORTS Beam, Chord, MusicDefs, Note, Piece, Score, Sheet, StreamDefs, Sync, Utility 
EXPORTS Score
= BEGIN OPEN MusicDefs, MusicFileDefs;

Error: SIGNAL;


version: INTEGER;

FileIn: PUBLIC PROC[s: STRING, append: BOOLEAN] = BEGIN
tie: TieFormat;
temp: SyncPTR;
note: NoteFormat;
view: ViewFormat;
event: EventFormat;
beam: BeamFormat;
chord: ChordFormat;
pointer: RelativePTR;
inputStream: StreamDefs.DiskHandle;
n: NotePTR; c: ChordPTR; last, lastP: Time _ 0;
i, j, k, length, oldBHLength, oldSLength, oldCHLength: CARDINAL;
inputStream _ StreamDefs.NewWordStream[s, StreamDefs.Read];
inputStream.reset[inputStream];
[] _ GetBlock[inputStream, NIL, 0]; --signal to fill up buffer
version _ Get[inputStream];
IF NOT append THEN Utility.InitStorage[];
oldBHLength _ beamHeapLength; 
oldSLength _ scoreLength; 
oldCHLength _ chordHeapLength; 
IF scoreLength#0 THEN last _ score[scoreLength-1].time+20; 
IF scoreLength#0 THEN lastP _ Piece.MaxToc[score, last-50, last, TRUE]; 
IF Get[inputStream]#scoreID THEN Error;
length _ Get[inputStream];
FOR i IN [oldSLength..oldSLength+length) DO
[] _ GetBlock[inputStream,@event, SIZE[EventFormat]];
BuildEvent[(score[i] _ Utility.NewSync[]),@event];
FOR j IN [0..event.length) DO
[] _ GetBlock[inputStream,@note, SIZE[NoteFormat]];
BuildNote[(score[i].event[j] _ Utility.NewNote[]),@note];
score[i].event[j].sync _ score[i];
IF NOT note.tie THEN LOOP;
[] _ GetBlock[inputStream,@tie, SIZE[TieFormat]];
score[i].event[j].tie _ score[tie.heap+oldSLength].event[tie.index];
score[i].event[j].tieHeight _ tie.height;
score[i].event[j].tie.tied _ TRUE;
ENDLOOP;
IF event.exception THEN
{
sheet: Staves _ [, 0, 0, 0,,];
[] _ GetBlock[inputStream,@sheet, SIZE[SheetFormat]];
BuildSheet[score[i],@sheet];
};
temp _ score[i];
IF score[i].time=-1 AND score[i].type=staves THEN { -- sort the score
FOR j IN [oldSLength..i) DO score[j+1]_ score[j]; ENDLOOP;
score[oldSLength] _ temp;
score[oldSLength].time _ 0};
IF append THEN Sync.AddTimes[temp, last, lastP];
scoreLength _ i+1;
ENDLOOP;
IF Get[inputStream]#chordHeapID THEN Error;
length _ Get[inputStream];
FOR i IN [oldCHLength..oldCHLength+length) DO
[] _ GetBlock[inputStream,@chord, SIZE[ChordFormat]];
BuildChord[(chordHeap[i] _ Utility.NewChord[]),@chord];
FOR j IN [0..chord.length) DO
[] _ GetBlock[inputStream,@pointer, SIZE[RelativePTR]];
chordHeap[i].note[j] _ score[pointer.heap+oldSLength].event[pointer.index];
chordHeap[i].note[j].chord _ chordHeap[i];
ENDLOOP;
ENDLOOP;
IF Get[inputStream]#beamHeapID THEN Error;
length _ Get[inputStream];
FOR i IN [oldBHLength..oldBHLength+length) DO beamHeap[i] _ Utility.NewBeam[]; ENDLOOP;
FOR i IN [oldBHLength..oldBHLength+length) DO
[] _ GetBlock[inputStream,@beam, SIZE[BeamFormat]];
FOR j IN [0..beam.length) DO
[] _ GetBlock[inputStream,@pointer, SIZE[RelativePTR]];
SELECT pointer.heap FROM
beams => {
beamHeap[i].chord[j] _ [beam[beamHeap[pointer.index+oldBHLength]]];
beamHeap[pointer.index+oldBHLength].beam _ beamHeap[i];
}; 
chords =>{
c _ chordHeap[pointer.index+oldCHLength];
beamHeap[i].chord[j] _ [chord[c]];
FOR k IN [0..chordLength) DO
IF c.note[k] = NIL THEN EXIT;
c.note[k].beam _ beamHeap[i];
ENDLOOP;
}; 
ENDCASE=>{
n _ score[pointer.heap+oldSLength].event[pointer.index];
beamHeap[i].chord[j] _ [note[n]];
n.beam _ beamHeap[i];
}; 
BuildBeam[beamHeap[i],@beam];
ENDLOOP;
ENDLOOP;
FOR i IN [oldBHLength..oldBHLength+length) DO 
Beam.SetSyncs[beamHeap[i]]; 
ENDLOOP;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
IF Get[inputStream]#nullID THEN Error;
[] _ GetBlock[inputStream,@view, SIZE[ViewFormat]];
BuildView[@view];
bufferIndex _ 0;
inputStream.destroy[inputStream];
command _ TRUE;
Score.FileStats[];
Sheet.SetBegin[0];
END;

Get: PROC[s: StreamDefs.DiskHandle] RETURNS[data: UNSPECIFIED] =
INLINE { [] _ GetBlock[s,@data, 1]; };

GetBlock: PROC[s: StreamDefs.DiskHandle, p: POINTER, length: CARDINAL] RETURNS[INTEGER] = {
i: CARDINAL;
array: POINTER TO ARRAY[0..1000) OF INTEGER _ LOOPHOLE[p];
IF p=NIL THEN {
[] _ StreamDefs.ReadBlock[s,@buffer, bufferLength];
bufferIndex _ 0;
RETURN[0];
};
FOR i IN [0..length) DO
array[i] _ buffer[bufferIndex];
bufferIndex _ bufferIndex+1;
IF bufferIndex< bufferLength THEN LOOP;
[] _ StreamDefs.ReadBlock[s,@buffer, bufferLength];
bufferIndex _ 0;
ENDLOOP;
RETURN[0];
};

BuildEvent: PROC[old: SyncPTR, new: POINTER TO EventFormat] = {
IF new.identifier#eventID THEN Error;
old.time _ new.time;
SELECT version FROM
1 => old.type _ LOOPHOLE[LOOPHOLE[new.type, CARDINAL]/4];
ENDCASE => old.type _ new.type;
IF old.type=timeSignature THEN old.ts _ LOOPHOLE[new.value] 
ELSE old.value_ new.value;
}; 

BuildSheet: PROC[old: SyncPTR, staves: StavesPTR] = {
old.event _ LOOPHOLE[staves^];
staves _ LOOPHOLE[@old.event];
IF version<3 THEN ConvertSheet2[old];
IF old.type=staves AND old.value=-1 THEN FindStyle[old];
};

ConvertSheet2: PROC[old: SyncPTR] = {
staves: StavesPTR _ LOOPHOLE[@old.event];
IF old.value=-1 THEN {old.type _ staves; RETURN};
IF staves.staff[old.value].pitch=15 THEN {
old.type _ octava1;
staves.height _ -30;
RETURN};
IF staves.staff[old.value].pitch=60 THEN {
old.type _ octava1;
staves.height _ 60;
RETURN};
FOR i: CARDINAL DECREASING IN [0..scoreLength) DO
IF score[i].type NOT IN SheetSwitch THEN LOOP;
staves _ LOOPHOLE[@score[i].event];
SELECT staves.staff[old.value].pitch FROM
15 => old.type _ octava2;
60 => old.type _ octava2;
ENDCASE => old.type _ clef;
RETURN; ENDLOOP;
};

FindStyle: PROC[old: SyncPTR] = {
staves: StavesPTR _ LOOPHOLE[@old.event];
index: INTEGER _ 1;
FOR i: CARDINAL IN [1..staves.sl] DO
IF staves.staff[i].y=staves.staff[i-1].y THEN LOOP;
index _ index+1;
ENDLOOP;
IF index=4 AND staves.staff[0].pitch=72 THEN index _ 0;
old.value _ index;
staves^ _ style[index];
}; 

BuildNote: PROC[old: NotePTR, new: POINTER TO NoteFormat] = {
IF new.identifier#noteID THEN Error;
old.pitch _ new.pitch;
old.value _ new.value;
old.embellish _ new.embellish;
old.grace _ new.grace;
old.voice _ new.voice;
maxVoice _ MAX[old.voice, maxVoice];
old.spelled _ new.spelled;
old.rest _ new.rest;
old.dotted _ new.dotted;
old.doubleDotted _ new.doubleDotted;
old.stemUp _ new.stemUp;
old.staff _ new.staff;
old.toc _ new.toc;
old.duration _ new.duration;
}; 

BuildChord: PROC[old: ChordPTR, new: POINTER TO ChordFormat] = {
IF new.identifier#chordID THEN Error;
old.stemUp _ new.stemUp;
}; 

BuildBeam: PROC[old: BeamPTR, new: POINTER TO BeamFormat] = {
IF new.identifier#beamID THEN Error;
old.tilt _ new.tilt;
old.beamed _ new.beamed;
old.invisible _ new.invisible;
old.ntuple _ new.ntuple;
old.against _ new.against;
old.height _ new.height;
old.staff _ new.staff;
Beam.SetSyncs[old];
}; 

BuildView: PROC[view: POINTER TO ViewFormat] = {
TF _ view.scale;
IF view.display#physical AND TF>10 THEN TF _ 3; --temporary hack
SELECT view.sheet FROM -- convert from old indices to new ones
1   => Score.Look[sheet,, 0];
6, 7 => Score.Look[sheet,, 1];
2   => Score.Look[sheet,, 2];
4, 5 => Score.Look[sheet,, 3];
3   => Score.Look[sheet,, 4];
ENDCASE;
show.accidental _ view.accidental;
show.sync _ view.sync;
show.notehead _ view.notehead;
show.display _ view.display;
show.noCarry _ view.noCarry;
Score.Look[hardcopy, view.hardcopy,];
IF version=1 THEN Score.SetKey[0, EndOfScore[], view.key];
IF version=1 THEN Score.SetMetrenome[0, EndOfScore[], view.speed];
Sheet.Reset[];
};


FO: PROC RETURNS[STRING] = {
RETURN[IF FileOut["temp.music"] 
THEN "filed out on temp.music"	
ELSE "fileout aborted"];
};

buffer: ARRAY [0..bufferLength) OF INTEGER;
bufferIndex: CARDINAL _ 0;
bufferLength: CARDINAL = 500;

FileOut: PUBLIC PROC[s: STRING] RETURNS[BOOLEAN] = {
OPEN StreamDefs;
i, j: CARDINAL;
outputStream: StreamDefs.DiskHandle;
event: EventFormat;
note: NoteFormat;
chord: ChordFormat;
beam: BeamFormat;
tie: TieFormat;
view: ViewFormat;
pointer: RelativePTR;
n: NotePTR;
IF Score.Test[] THEN RETURN[FALSE]; 
outputStream _ StreamDefs.NewWordStream[s, StreamDefs.Write+StreamDefs.Append];
outputStream.reset[outputStream];
Put[outputStream, versionID];
Put[outputStream, scoreID];
Put[outputStream, scoreLength];
FOR i IN [0..scoreLength) DO
ConvertEvent[score[i],@event];
[] _ PutBlock[outputStream,@event, SIZE[EventFormat]];
IF event.exception THEN
{
sheet: Staves _ LOOPHOLE[score[i].event];
[] _ PutBlock[outputStream,@sheet, SIZE[SheetFormat]];
};
FOR j IN [0..syncLength) DO
IF (n _ score[i].event[j])=NIL THEN EXIT;
ConvertNote[n,@note];
note.tie _ n.tie#NIL;
[] _ PutBlock[outputStream,@note, SIZE[NoteFormat]];
IF NOT note.tie THEN LOOP;
tie.heap _ Sync.GetScoreIndex[n.tie.sync];
tie.index _ Note.GetSyncIndex[n.tie.sync, n.tie];
tie.height _ score[i].event[j].tieHeight;
[] _ PutBlock[outputStream,@tie, SIZE[TieFormat]]
ENDLOOP;
ENDLOOP;
Put[outputStream, chordHeapID];
Put[outputStream, chordHeapLength];
FOR i IN [0..chordHeapLength) DO
ConvertChord[chordHeap[i],@chord];
[] _ PutBlock[outputStream,@chord, SIZE[ChordFormat]];
pointer.heap _ Sync.GetScoreIndex[chordHeap[i].note[0].sync];	    
FOR j IN [0..chordLength) DO
IF chordHeap[i].note[j] = NIL THEN EXIT;
pointer.index _ Note.GetSyncIndex[score[pointer.heap], chordHeap[i].note[j]];
[] _ PutBlock[outputStream,@pointer, SIZE[RelativePTR]];
ENDLOOP;
ENDLOOP;
Put[outputStream, beamHeapID];
Put[outputStream, beamHeapLength];
FOR i IN [0..beamHeapLength) DO
ConvertBeam[beamHeap[i],@beam];
[] _ PutBlock[outputStream,@beam, SIZE[BeamFormat]];
FOR j IN [0..beamLength) DO
IF beamHeap[i].chord[j] = endOfBeam THEN EXIT;
WITH ev: beamHeap[i].chord[j] SELECT FROM
note => {
pointer.heap _ Sync.GetScoreIndex[ev.n.sync];
pointer.index_ Note.GetSyncIndex[score[pointer.heap], ev.n];
};
chord=> {
pointer.heap _ chords;
pointer.index_ Chord.GetHeapIndex[ev.c];
};
beam => {
pointer.heap _ beams;
pointer.index_ Beam.GetHeapIndex[ev.b];
};
ENDCASE;
[] _ PutBlock[outputStream,@pointer, SIZE[RelativePTR]];
ENDLOOP;
ENDLOOP;
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
Put[outputStream, nullID];
ConvertView[@view];
[] _ PutBlock[outputStream,@view, SIZE[ViewFormat]];
[] _ PutBlock[outputStream, NIL, 0]; --clean up buffer
outputStream.destroy[outputStream];
command _ TRUE;
RETURN[TRUE];
};

Put: PROC[s: StreamDefs.DiskHandle, data: INTEGER] =
INLINE { [] _ PutBlock[s,@data, 1]; };

PutBlock: PROC[s: StreamDefs.DiskHandle, p: POINTER, length: CARDINAL] RETURNS[INTEGER] = {
i: CARDINAL;
array: POINTER TO ARRAY[0..1000) OF INTEGER _ LOOPHOLE[p];
IF length=0 THEN {
IF bufferIndex=0 THEN RETURN[0];
[] _ StreamDefs.WriteBlock[s,@buffer, bufferIndex];
bufferIndex _ 0;
RETURN[0]; };
FOR i IN [0..length) DO
buffer[bufferIndex] _ array[i];
bufferIndex _ bufferIndex+1;
IF bufferIndex< bufferLength THEN LOOP;
[] _ StreamDefs.WriteBlock[s,@buffer, bufferIndex];
bufferIndex _ 0;
ENDLOOP;
RETURN[0];
};

ConvertEvent: PROC[data: SyncPTR, file: POINTER TO EventFormat] = {
file^ _ []; --defaults to the values listed in musicFileDefs
file.time _ data.time;
file.type _ data.type;
SELECT data.type FROM
notes => file.length _ Sync.Length[data];
timeSignature => file.value _ LOOPHOLE[data.ts];
ENDCASE => file.value _ data.value;
IF data.type IN SheetSwitch THEN file.exception _ TRUE; 
}; 

ConvertNote: PROC[old: NotePTR, new: POINTER TO NoteFormat] = {
new.pitch _ old.pitch;
new.value _ old.value;
new.embellish _ old.embellish;
new.voice _ old.voice;
new.spelled _ old.spelled;
new.rest _ old.rest;
new.dotted _ old.dotted;
new.doubleDotted _ old.doubleDotted;
new.grace _ old.grace;
new.stemUp _ old.stemUp;
new.staff _ old.staff;
new.toc _ old.toc;
new.duration _ old.duration;
}; 

ConvertChord: PROC[old: ChordPTR, new: POINTER TO ChordFormat] = {
new.stemUp _ old.stemUp;
new.length _ Chord.Length[old];
}; 

ConvertBeam: PROC[old: BeamPTR, new: POINTER TO BeamFormat] = {
new.tilt _ old.tilt;
new.beamed _ old.beamed;
new.invisible _ old.invisible;
new.ntuple _ old.ntuple;
new.against _ old.against;
new.height _ old.height;
new.staff _ old.staff;
new.length _ Beam.Length[old];
}; 

ConvertView: PROC[view: POINTER TO ViewFormat] = {
view.scale _ TF;
view.sheet _ 0;
view.speed _ 128;
view.accidental _ show.accidental;
view.sync _ show.sync;
view.notehead _ show.notehead;
view.display _ show.display;
view.noCarry _ show.noCarry;
view.hardcopy _ hardcopy;
};

END.



ConvertReals: PROC = {
i: CARDINAL;
FOR i IN [0..beamHeapLength) DO
IF beamHeap[i]=NIL THEN LOOP;
beamHeap[i].tilt _ RealConvert.Mesa5ToIeee[beamHeap[i].tilt];
ENDLOOP;
}; 


FileInOld: PUBLIC PROC[s: STRING] = {
OPEN DataDefs, StreamDefs;
i, length: CARDINAL _ 0;
pn: PhysicalNote;
note: NotePTR;
sync: SyncPTR _ NIL;
oldToc: Time;
inputStream: DiskHandle;
inputStream _ NewWordStream[s, Read];
inputStream.reset[inputStream];
length _ inputStream.get[inputStream];
[] _ inputStream.get[inputStream];
NewScore[];
WHILE NOT inputStream.endof[inputStream] DO
[] _ ReadBlock[inputStream,@pn, SIZE[PhysicalNote]];
IF pn.duration<4 THEN LOOP;
IF pn.pitch>80 OR pn.pitch<-7 THEN LOOP;
note _ NewNote[];
note^ _ []; --defaults to the values listed in musicDefs
note.toc _ pn.toc;
note.duration _ pn.duration;
note.pitch _ pn.pitch;
SELECT TRUE FROM
note.pitch IN [67..80] => { note.stemUp _ FALSE; note.staff _ 0; };
note.pitch IN [56..66] => { note.stemUp_ TRUE; note.staff _ 0; };
note.pitch IN [43..55] => { note.stemUp _ FALSE; note.staff _ 1; };
note.pitch IN [32..42] => { note.stemUp_ TRUE; note.staff _ 1; };
note.pitch IN [22..31] => { note.stemUp _ FALSE; note.staff _ 2; };
note.pitch IN [10..21] => { note.stemUp_ TRUE; note.staff _ 2; };
note.pitch IN [ 0.. 9] => { note.stemUp _ FALSE; note.staff _ 3; };
note.pitch IN [-7..-1] => { note.stemUp_ TRUE; note.staff _ 3; };
ENDCASE;
IF ABS[note.toc - oldToc] > 200 
THEN {
AddSyncToPiece[sync, score];
oldToc _ note.toc;
sync _ NewSync[];
};
sync.time _ note.toc/256;
AddToSync[sync, note];
i _ i + 1;
IF i=length THEN EXIT;
ENDLOOP;
AddSyncToPiece[sync, score];
inputStream.destroy[inputStream];
ActionDefs.Look[accidental, FALSE,];
ActionDefs.Look[sheet,, 1];
ActionDefs.Look[notehead, FALSE,];
selectionLength _ 0;
SortScore[];
UtilityDefs.DrawScore[TRUE];
};

FileOutOld: PUBLIC PROC[s: STRING] = {
OPEN StreamDefs;
i, j: CARDINAL;
pNote: PhysicalNote;
n: NotePTR;
inputStream: DiskHandle;
inputStream _ NewWordStream[s, Write+Append];
inputStream.reset[inputStream];
inputStream.put[inputStream, 0];
inputStream.put[inputStream, 0];
FOR i IN [0..scoreLength) DO
FOR j IN [0..syncLength) DO
IF (n _ score[i].event[j])=NIL THEN EXIT;
IF score[i].event[j].rest THEN LOOP;
IF n.duration = 0 THEN LOOP;
pNote _ [n.pitch, n.duration, 50, n.toc];
[] _ WriteBlock[inputStream,@pNote, SIZE[PhysicalNote]];
ENDLOOP;
ENDLOOP;
inputStream.destroy[inputStream];
UtilityDefs.DrawScore[TRUE];
};


}....

FileInOld: PUBLIC PROC[s: STRING] = {
OPEN StreamDefs;
i, j, noChords, noBeams: CARDINAL;
rchord: RChord;
rbeam: RBeam;
convert: BOOLEAN _ FALSE;
inputStream: DiskHandle;
inputStream _ NewWordStream[s, Read];
inputStream.reset[inputStream];
IF append THEN InitAppend[] ELSE NewScore[]; 
scoreLength _ inputStream.get[inputStream]+start;
maxVoice _ 0;
FOR i IN [start..scoreLength) DO score[i] _ NewSync[]; ENDLOOP;
FOR i IN [start..scoreLength) DO
[] _ ReadBlock[inputStream, score[i], SIZE[Sync]];
score[i].time _ score[i].time + offset;
FOR j IN [0..syncLength) DO
IF score[i].event[j]=NIL THEN EXIT;
[] _ ReadBlock[inputStream, score[i].event[j] _ NewNote[], SIZE[Note]];
score[i].event[j].sync _ score[i];
IF skipBeams THEN score[i].event[j].beam _ NIL;
maxVoice _ MAX[maxVoice, score[i].event[j].voice];
ENDLOOP;
ENDLOOP;
noChords _ inputStream.get[inputStream];
FOR i IN [0..noChords) DO
[] _ ReadBlock[inputStream,@rchord, SIZE[RChord]];
RestoreChord[@rchord, NewChord[]];
ENDLOOP;
noBeams _ inputStream.get[inputStream];
FOR i IN [0..noBeams) DO
[] _ ReadBlock[inputStream,@rbeam, SIZE[RBeam]];
IF skipBeams THEN LOOP;
RestoreBeam[@rbeam, NewBeam[]];
IF rbeam.beam.tilt> 3 OR rbeam.beam.tilt<-3 THEN convert _ TRUE;
ENDLOOP;
IF NOT inputStream.endof[inputStream] THEN FileInSheet[inputStream];
inputStream.destroy[inputStream];
IF convert THEN Convert[];
UtilityDefs.ResetSheet[];
};

FileInSheet: PROC[stream: StreamDefs.DiskHandle]= {
OPEN StreamDefs;
[] _ ReadBlock[stream,@keyArray, 2*keyLength];
[] _ ReadBlock[stream,@show, SIZE[DocumentProfile]];
[] _ ReadBlock[stream,@metrenome, SIZE[INTEGER]];
[] _ ReadBlock[stream,@TF, SIZE[CARDINAL]];
[] _ ReadBlock[stream,@sheet, SIZE[Staves]];
sheet.staff[4] _ [0, 0]; sheet.staff[5] _ [0, 0];
KeyIndexToSync[];
};

KeyIndexToSync: PROC = {
k: CARDINAL;
FOR k IN [0..keyLength) DO
keyArray[k].sync _ score[LOOPHOLE[keyArray[k].sync, CARDINAL]];
ENDLOOP;
};


skipBeams: BOOLEAN _ FALSE;
bstart, cstart: CARDINAL _ 0;
offset: Time _ 0;
append: BOOLEAN _ FALSE;

InitAppend: PROC = {
start _ scoreLength;
bstart _ beamHeapLength;
cstart _ chordHeapLength;
IF scoreLength#0 THEN offset _ score[scoreLength-1].time+10;
};

RestoreChord: PROC[r: POINTER TO RChord, chord: ChordPTR] = {
i: CARDINAL;
chord^ _ [r.stem, 0, ALL[NIL]];
FOR i IN [0..chordLength) DO
IF r.n[i]=100 THEN EXIT;
chord.note[i] _ score[r.s+start].event[r.n[i]];
ENDLOOP;
};

RestoreBeam: PROC[r: POINTER TO RBeam, beam: BeamPTR]= {
i, j: CARDINAL;
beam^ _ r.beam;
beam.sync1 _ score[LOOPHOLE[beam.sync1, CARDINAL]+start];
beam.sync2 _ score[LOOPHOLE[beam.sync2, CARDINAL]+start];
FOR i IN [0..beamLength) DO
IF r.n[i].type = null THEN EXIT;
SELECT r.n[i].type FROM
note => beam.chord[i] _ 
[note[score[r.n[i].sync+start].event[r.n[i].index]]];
chord=> beam.chord[i] _ [chord[chordHeap[r.n[i].index+cstart]]];
beam => beam.chord[i] _ [beam[beamHeap[r.n[i].index+bstart]]];
null => beam.chord[i] _ endOfBeam;
ENDCASE =>NULL; --later ERROR
ENDLOOP;
FOR i IN [0..beamLength) DO
WITH ev: beam.chord[i] SELECT FROM
note => IF ev.n#NIL THEN ev.n.beam _ beam;
chord=> FOR j IN [0..chordLength) DO
IF ev.c.note[j]#NIL THEN ev.c.note[j].beam _ beam;
ENDLOOP;
beam => SetBeamPTRToBeam[ev.b, beam];
ENDCASE;
ENDLOOP;
};

RChord: TYPE = RECORD[s: CARDINAL, stem: BOOLEAN,
n: ARRAY [0..chordLength) OF CARDINAL];  
RBeam: TYPE = RECORD[beam: BeamedSet, n: ARRAY [0..beamLength) OF VPointer];
VPointer: TYPE = RECORD[type: {note, chord, beam, null}, sync: CARDINAL, index: CARDINAL];  


FileOutOld: PUBLIC PROC[s: STRING] = {
OPEN StreamDefs;
i, j: CARDINAL;
rchord: RChord;
rbeam: RBeam;
inputStream: DiskHandle;
IF UtilityDefs.Test[] THEN ERROR; -- PLEASE save MESA.TYPESCRIPT for me to examine!
inputStream _ NewWordStream[s, Write+Append];
inputStream.reset[inputStream];
inputStream.put[inputStream, scoreLength];
FOR i IN [0..scoreLength) DO
[] _ WriteBlock[inputStream, score[i], SIZE[Sync]];
FOR j IN [0..syncLength) DO
IF score[i].event[j]=NIL THEN EXIT;
[] _ WriteBlock[inputStream, score[i].event[j], SIZE[Note]];
ENDLOOP;
ENDLOOP;
inputStream.put[inputStream, chordHeapLength];
FOR i IN [0..chordHeapLength) DO
rchord _ RelativeChord[chordHeap[i]];
[] _ WriteBlock[inputStream,@rchord, SIZE[RChord]];
ENDLOOP;
inputStream.put[inputStream, beamHeapLength];
FOR i IN [0..beamHeapLength) DO
rbeam _ RelativeBeam[beamHeap[i]];
[] _ WriteBlock[inputStream,@rbeam, SIZE[RBeam]];
ENDLOOP;
FileOutSheet[inputStream];
inputStream.destroy[inputStream];
command _ TRUE;
UtilityDefs.DrawScore[TRUE];
};

FileOutSheet: PROC[stream: StreamDefs.DiskHandle]= {
OPEN StreamDefs;
KeySyncToIndex[];
[] _ WriteBlock[stream,@keyArray, 2*keyLength];
[] _ WriteBlock[stream,@show, SIZE[DocumentProfile]];
[] _ WriteBlock[stream,@metrenome, SIZE[INTEGER]];
[] _ WriteBlock[stream,@TF, SIZE[CARDINAL]];
[] _ WriteBlock[stream,@sheet, SIZE[Staves]];
KeyIndexToSync[];
};

KeySyncToIndex: PROC = {
i, k: CARDINAL;
syncFound: BOOLEAN;
FOR k IN [0..keyLength) DO
syncFound _ FALSE;
FOR i IN [0..scoreLength] DO
IF score[i]#keyArray[k].sync THEN LOOP;
syncFound _ TRUE;
keyArray[k].sync _ LOOPHOLE[i];
EXIT;
ENDLOOP;
IF NOT syncFound THEN ERROR;
ENDLOOP;
};

RelativeChord: PROC[c: ChordPTR] RETURNS[RChord]= {
i, j: CARDINAL;
r: RChord _ [0, c.stemUp, ALL[100]];
FOR i IN [0..scoreLength) DO 
IF score[i]=c.note[0].sync THEN { r.s _ i; EXIT; };
ENDLOOP;
FOR i IN [0..chordLength) DO
IF c.note[i]=NIL THEN EXIT;
FOR j IN [0..syncLength) DO
IF score[r.s].event[j] # c.note[i] THEN LOOP;
r.n[i] _ j; EXIT;
ENDLOOP;
ENDLOOP;
RETURN[r];
};

RelativeBeam: PROC[b: BeamPTR] RETURNS[RBeam]= {
i, j: CARDINAL;
r: RBeam;
r.beam _ b^;
r.n _ ALL[[null, 0, 0]];
FOR i IN [0..scoreLength) DO
IF r.beam.sync1=score[i] THEN r.beam.sync1 _ LOOPHOLE[i];
IF r.beam.sync2=score[i] THEN r.beam.sync2 _ LOOPHOLE[i];
ENDLOOP;
IF LOOPHOLE[r.beam.sync1, CARDINAL]>scoreLength THEN ERROR;
IF LOOPHOLE[r.beam.sync2, CARDINAL]>scoreLength THEN ERROR;
FOR i IN [0..beamLength) DO
IF b.chord[i]=endOfBeam THEN EXIT;
WITH ev: b.chord[i] SELECT FROM
chord => {
r.n[i].type _ chord;
FOR j IN [0..chordHeapLength) DO
IF chordHeap[j]=ev.c THEN r.n[i].index _ j;
ENDLOOP;
};
beam  => {
r.n[i].type _ beam;
FOR j IN [0..beamHeapLength) DO
IF beamHeap[j]=ev.b THEN r.n[i].index _ j;
ENDLOOP;
};
note  => {
r.n[i].type _ note;
FOR j IN [0..scoreLength) DO
IF score[j]=ev.n.sync THEN r.n[i].sync _ j;
ENDLOOP;
FOR j IN [0..syncLength) DO
IF score[r.n[i].sync].event[j]=ev.n 
THEN r.n[i].index _ j;
ENDLOOP;
};
ENDCASE;
ENDLOOP;
RETURN[r];
};


œFilerImpl.mesa
Copyright (C) 1981, 1984 Xerox Corporation. All rights reserved.
Author: John Maxwell
last modified: December 16, 1981  7: 58 AM
Edited by Doug Wyatt, June 14, 1984 1:07:22 pm PDT
****************************************************************************
filein, fileout
****************************************************************************
prepare for append
file in score
file in chordheap
file in beamheap
file in spares
file in view
clean up and return
a hack to speed up disk transfers by batching them together
is the present clef change the latter part of an octava pair?
****************************************************************************
fileout
****************************************************************************
file out score
file out chordheap
file out beamheap
file out nine spares
file out view
clean up and return
a hack to speed up disk transfers by batching them together
****************************************************************************
filein, fileout pianorolls
****************************************************************************
************************************************************************
filein, fileout old .logical format
************************************************************************
UtilityDefs.DrawScore[TRUE];
to try to recover, SEt Root & SEt Module to utility,
Interpret Procedure: cleanUp,
SEt Root & Module to MusicData,
Interpret Procedure: fo (for "FileOut"),
save the mesa.typescript somewhere(like ivy) and then
reinvoke mockingbird and filein temp.logical.
If this doesn't work, I may still be able to recover
part of the file if you save temp.logical somewhere.
�Ê¥˜š
œ™Jš
œ@™@Jš
œ™Jš
œ*™*J™2J˜—š
Ïk	˜	Jšœ�œ"˜,Jšœ�œ˜#J˜
J˜Jšœ�œ˜Jšœ�œ
˜Jšœ�œ/˜:Jšœ�œ˜Jšœ�œI˜YJšœ�œ#˜-Jšœ�œ4˜AJ˜—Jšœ�œ
�˜Jš�œN˜UJš�œ˜
Jšœ�œ
�œ˜&J˜Jšœ�œ
˜J˜Jš
œL™LJš
œ™Jš
œL™LJ˜Jšœ	�œ
˜J˜šÏnœ�œ
�œ�œ
�œ�˜7J˜J˜J˜J˜J˜J˜J˜J˜J˜#J˜/Jšœ7�œ
˜@J˜;J˜Jšœ�œÏc˜>J˜Jš
œ™Jš�œ
�œ�œ˜)J˜J˜J˜Jš�œ�œ&˜;Jš�œ�œ,�œ˜HJš
œ
™
Jš�œ�œ˜'J˜š�œ�œ!�˜+Jšœ"�œ˜5J˜2š�œ�œ�˜Jšœ!�œ˜3J˜9J˜"Jš�œ
�œ
�œ
�œ
˜Jšœ �œ
˜1J˜DJ˜)Jšœ�œ
˜"Jš�œ
˜—š�œ�˜Jš
œ
˜
J˜Jšœ"�œ˜5J˜Jš
œ˜—J˜š�œ�œ�œŸ˜EJš�œ�œ�œ�œ
˜:J˜J˜—Jš�œ�œ"˜0J˜Jš�œ
˜—Jš
œ™Jš�œ�œ˜+J˜š�œ�œ#�˜-Jšœ"�œ˜5J˜7š�œ�œ�˜Jšœ$�œ˜7J˜KJ˜*Jš�œ
˜—Jš�œ
˜—Jš
œ™Jš�œ�œ˜*J˜Jš�œ�œ#�œ"�œ
˜Wš�œ�œ#�˜-Jšœ!�œ˜3š�œ�œ�˜Jšœ$�œ˜7š�œ�˜š
œ
˜
J˜CJ˜7Jš
œ˜—š
œ
˜
J˜)J˜"š�œ�œ�˜Jš�œ
�œ
�œ
�œ
˜J˜Jš�œ
˜—Jš
œ˜—š�œ˜
J˜8J˜!J˜Jš
œ˜——J˜Jš�œ
˜—Jš�œ
˜—š�œ�œ#�œ
˜.J˜Jš�œ
˜—Jš
œ™Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš�œ�œ˜&Jš
œ™Jšœ!�œ˜3J˜Jš
œ™J˜J˜!Jšœ
�œ
˜J˜J˜Jš�œ
˜—J˜Jšžœ�œ�œ�œ˜@Jš�œ ˜&J˜Jšžœ�œ�œ
�œ�œ
�œ˜[š
œ;™;Jšœ�œ
˜Jš
œ�œ
�œ
�œ
�œ
�œ�œ˜:š�œ�œ
�œ˜J˜3J˜Jš�œ˜
Jš
œ˜—š�œ�œ
�˜J˜J˜Jš�œ�œ
�œ
˜'J˜3J˜Jš�œ
˜—Jš�œ˜
Jš
œ˜—J˜šž
œ�œ�œ
�œ˜?Jš�œ�œ˜%J˜š�œ	�˜Jšœ�œ
�œ�œ˜9Jš�œ˜—š�œ�œ
�œ˜<Jš�œ˜—Jš
œ˜—J˜šž
œ�œ%˜5Jšœ�œ
˜Jšœ	�œ
˜Jš�œ�œ˜%Jš�œ�œ�œ˜8Jš
œ˜—J˜šž
œ�œ˜%Jšœ�œ
˜)Jš�œ�œ�œ˜1š�œ"�œ˜*J˜J˜Jš�œ˜—š�œ"�œ˜*J˜J˜Jš�œ˜—š	�œ�œ
�
œ
�œ�˜1Jš
œ=™=Jš
�œ�œ
�œ
�œ
�œ
˜.Jšœ	�œ˜#š�œ�˜)J˜J˜Jš�œ˜—Jš�œ�œ
˜—Jš
œ˜—J˜šž	œ�œ˜!Jšœ�œ
˜)Jšœ�œ˜š�œ�œ
�œ�˜$Jš�œ'�œ
�œ
˜3J˜Jš�œ
˜—Jš�œ	�œ�œ˜7J˜Jš
œ˜Jš
œ˜—J˜šž	œ�œ�œ
�œ˜=Jš�œ�œ˜$J˜J˜J˜J˜J˜Jšœ�œ˜$J˜J˜J˜J˜$J˜J˜J˜J˜Jš
œ˜—J˜šž
œ�œ�œ
�œ˜@Jš�œ�œ˜%J˜Jš
œ˜—J˜šž	œ�œ�œ
�œ˜=Jš�œ�œ˜$J˜J˜J˜J˜J˜J˜J˜J˜Jš
œ˜—J˜šž	œ�œ�œ
�œ˜0Jš�œ˜Jš�œ�œ
�œ�œ
�œŸ˜@š�œ�œ
Ÿ'˜>J˜J˜J˜J˜J˜Jš�œ
˜—J˜"J˜J˜J˜J˜J˜%Jš�œ�œ)˜:Jš�œ�œ1˜BJ˜Jš
œ˜—J˜Jš
œL™LJš
œ™Jš
œL™LJ˜š�œ�œ
�œ
�œ˜š�œ
�œ˜ Jš�œ˜Jš�œ˜—Jš
œ˜—J˜Jšœ�œ�œ
�œ
˜+Jšœ
�œ˜Jšœ�œ˜J˜šžœ�œ
�œ�œ�œ
�œ˜4Jš�œ˜Jšœ�œ
˜J˜$J˜J˜J˜J˜J˜J˜J˜J˜Jš�œ�œ
�œ
�œ˜$J˜OJ˜!Jš
œ™J˜J˜J˜š�œ�œ�˜J˜Jšœ#�œ˜6š�œ�˜Jš
œ
˜
Jšœ�œ˜)Jšœ#�œ˜6Jš
œ˜—š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜)J˜šœ�œ
˜Jšœ"�œ˜4—Jš�œ
�œ
�œ
�œ
˜J˜*J˜1J˜)šœ!�œ˜1Jš�œ
˜——Jš�œ
˜—Jš
œ™J˜J˜#š�œ�œ�˜ J˜"Jšœ#�œ˜6J˜Bš�œ�œ�˜Jš�œ�œ
�œ
�œ
˜(J˜MJšœ%�œ˜8Jš�œ
˜—Jš�œ
˜—Jš
œ™J˜J˜"š�œ�œ�˜J˜Jšœ"�œ˜4š�œ�œ�˜Jš�œ"�œ
�œ
˜.Jš�œ�œ
�˜)š
œ	˜	J˜-J˜<Jš
œ˜—š
œ	˜	J˜J˜(Jš
œ˜—š
œ	˜	J˜J˜'Jš
œ˜—Jš�œ
˜Jšœ%�œ˜8Jš�œ
˜—Jš�œ
˜—Jš
œ™J˜J˜J˜J˜J˜J˜J˜J˜J˜Jš
œ
™
J˜Jšœ"�œ˜4Jš
œ™Jšœ�œŸ˜6J˜#Jšœ
�œ
˜Jš�œ
�œ˜
Jš
œ˜—J˜Jšžœ�œ!�œ˜4Jš�œ ˜&J˜Jšžœ�œ�œ
�œ�œ
�œ˜[š
œ;™;Jšœ�œ
˜Jš
œ�œ
�œ
�œ
�œ
�œ�œ˜:š�œ
�œ˜Jš�œ�œ
�œ˜ J˜3J˜Jš�œ˜
—š�œ�œ
�˜J˜J˜Jš�œ�œ
�œ
˜'J˜3J˜Jš�œ
˜—Jš�œ˜
Jš
œ˜—J˜šžœ�œ�œ
�œ˜CJšœŸ0˜<J˜J˜š�œ�˜J˜)Jšœ�œ
˜0Jš�œ˜#—Jš�œ�œ
�œ�œ˜8Jš
œ˜—J˜šžœ�œ�œ
�œ˜?J˜J˜J˜J˜J˜J˜J˜J˜$J˜J˜J˜J˜J˜Jš
œ˜—J˜šžœ�œ�œ
�œ˜BJ˜J˜Jš
œ˜—J˜šžœ�œ�œ
�œ˜?J˜J˜J˜J˜J˜J˜J˜J˜Jš
œ˜—J˜šžœ�œ�œ
�œ˜2Jšœ
�œ
˜J˜J˜J˜"J˜J˜J˜J˜J˜Jš
œ˜—J˜Jš�œ
˜J˜J˜J˜šžœ�œ˜Jšœ�œ
˜š�œ�œ�˜Jš�œ
�œ
�œ
�œ
˜J˜=Jš�œ
˜—Jš
œ˜—J˜Jš
œL™LJš
œ™Jš
œL™LJ˜šž	œ�œ
�œ�œ˜%Jš�œ˜Jšœ�œ˜J˜J˜Jšœ�œ
˜J˜
J˜J˜%J˜J˜&J˜"J˜š�œ
�œ �˜+Jšœ �œ˜4Jš�œ�œ
�œ
˜Jš�œ
�œ
�œ
�œ
˜(J˜JšœŸ,˜8J˜J˜J˜š�œ
�œ
�˜Jšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJš�œ
˜—š�œ
�œ˜ š�œ˜J˜J˜J˜Jš
œ˜——J˜J˜J˜
Jš�œ
�œ
�œ
˜Jš�œ
˜—J˜J˜!Jšœ�œ˜$J˜Jšœ�œ˜"J˜J˜Jšœ�œ˜Jš
œ˜—J˜šž
œ�œ
�œ�œ˜&Jš�œ˜Jšœ�œ
˜J˜J˜J˜J˜-J˜J˜ J˜ š�œ�œ�˜š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜)Jš�œ�œ
�œ
˜$Jš�œ�œ
�œ
˜J˜)Jšœ$�œ˜8Jš�œ
˜—Jš�œ
˜—J˜!Jšœ�œ˜Jš
œ˜—J˜J˜Jš
œ˜Jš
œH™HJš
œ#™#Jš
œH™HJ˜šž	œ�œ
�œ�œ˜%Jš�œ˜Jšœ�œ
˜"J˜J˜
Jšœ	�œ�œ
˜J˜J˜%J˜Jš�œ�œ�œ
˜-J˜1J˜
Jš�œ�œ�œ�œ
˜?š�œ�œ�˜ Jšœ&�œ˜2J˜'š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜#Jšœ;�œ˜GJ˜"Jš�œ�œ�œ
˜/Jšœ�œ$˜2Jš�œ
˜—Jš�œ
˜—J˜(š�œ�œ�˜Jšœ$�œ
˜2J˜"Jš�œ
˜—J˜'š�œ�œ�˜Jšœ#�œ	˜0Jš�œ�œ
�œ
˜J˜Jš�œ�œ�œ�œ
˜@Jš�œ
˜—Jš�œ
�œ �œ˜DJ˜!Jš�œ	�œ˜J˜Jš
œ™Jš
œ˜—J˜šžœ�œ"˜3Jš�œ˜J˜.Jšœ�œ˜4Jšœ"�œ
�œ˜1Jšœ�œ�œ
�œ˜+Jšœ�œ
˜,J˜1J˜Jš
œ˜—J˜šžœ�œ˜Jšœ�œ
˜š�œ�œ�˜Jšœ�œ�œ˜?Jš�œ
˜—Jš
œ˜—J˜J˜Jšœ�œ�œ
˜Jšœ�œ˜J˜Jšœ�œ�œ
˜J˜šž
œ�œ˜J˜J˜J˜Jš�œ�œ'˜<Jš
œ˜—J˜šžœ�œ�œ
�œ˜=Jšœ�œ
˜Jšœ�œ
�œ˜š�œ�œ�˜Jš�œ�œ
�œ
˜J˜/Jš�œ
˜—Jš
œ˜—J˜šžœ�œ�œ
�œ˜8Jšœ�œ
˜J˜Jšœ�œ
�œ	˜9Jšœ�œ
�œ	˜9š�œ�œ�˜Jš�œ�œ
�œ
˜ š�œ
�˜˜J˜5—J˜@J˜>J˜"Jš�œ�œŸ
˜—Jš�œ
˜—š�œ�œ�˜š�œ�œ
�˜"Jšœ�œ�œ
�œ˜*šœ�œ�œ�˜$Jš�œ�œ
�œ˜2Jš�œ
˜—J˜%Jš�œ
˜—Jš�œ
˜—Jš
œ˜—J˜š	œ�œ�œ�œ�œ
˜1Jšœ�œ�œ
�œ˜)—Jš	œ�œ�œ�œ�œ˜LJš	œ
�œ�œ(�œ	�œ˜\J˜J˜šž
œ�œ
�œ�œ˜&Jš�œ˜Jšœ�œ
˜J˜J˜
J˜š�œ�œ
�œŸ1˜SJš
œ4™4Jš
œ™Jš
œ™Jš
œ(™(Jš
œ5™5Jš
œ-™-Jš
œ4™4Jš
œ4™4—J˜-J˜J˜*š�œ�œ�˜Jšœ'�œ˜3š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜#Jšœ0�œ˜<Jš�œ
˜—Jš�œ
˜—J˜.š�œ�œ�˜ J˜%Jšœ%�œ
˜3Jš�œ
˜—J˜-š�œ�œ�˜J˜"Jšœ$�œ	˜1Jš�œ
˜—J˜J˜!Jšœ
�œ
˜Jšœ�œ˜Jš
œ˜—J˜šžœ�œ"˜4Jš�œ˜J˜J˜/Jšœ�œ˜5Jšœ#�œ
�œ˜2Jšœ�œ�œ
�œ˜,Jšœ�œ
˜-J˜Jš
œ˜—J˜šžœ�œ˜Jšœ�œ
˜Jšœ�œ
˜š�œ�œ�˜Jšœ�œ
˜š�œ�œ�˜Jš�œ�œ
�œ
˜'šœ�œ
˜Jšœ�œ˜—Jš�œ
˜Jš�œ
˜—Jš�œ
�œ�œ
�œ
˜Jš�œ
˜—Jš
œ˜—J˜šž
œ�œ�œ˜3Jšœ�œ
˜Jšœ�œ˜$š�œ�œ�œ
˜Jš�œ�œ�œ˜3Jš�œ
˜—š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜š�œ�œ�˜Jš�œ!�œ
�œ
˜-Jšœ�œ
˜Jš�œ
˜—Jš�œ
˜—Jš�œ˜
Jš
œ˜—J˜šžœ�œ
�œ
˜0Jšœ�œ
˜J˜	J˜Jšœ�œ˜š�œ�œ�˜Jš�œ�œ�œ˜9Jš�œ�œ�œ˜9Jš�œ
˜—Jš
�œ
�œ�œ�œ
�œ
˜;Jš
�œ
�œ�œ�œ
�œ
˜;š�œ�œ�˜Jš�œ�œ
�œ
˜"š�œ�œ
�˜š
œ
˜
J˜š�œ�œ�˜ Jš�œ�œ˜+Jš�œ
˜—Jš
œ˜—š
œ
˜
J˜š�œ�œ�˜Jš�œ�œ˜*Jš�œ
˜—Jš
œ˜—š
œ
˜
J˜š�œ�œ�˜Jš�œ�œ˜+Jš�œ
˜—š�œ�œ�˜š�œ"˜$Jš�œ˜Jš�œ
˜——Jš
œ˜—Jš�œ
˜—Jš�œ
˜—Jš�œ˜
Jš
œ˜—J˜J˜—…—V"xc