sib2hum_0.11.plg


{
	Initialize "(){ AddToPluginsMenu('Convert Sibelius Score to Humdrum','Run');

// The following enables the latest behavior for the ManuScript interpreter.
// If you intend your plugin to run on previous versions of Sibelius where that functionality
// didn't exist, you will likely have to revisit the following:
if (Sibelius.ProgramVersion > 20200600) {
    SetInterpreterOption(TreatSingleCharacterAsString);
    SetInterpreterOption(SupportHalfSemitonePitchValues);
} }"
	Run "() {
// Convert Sibelius Score to Humdrum Kern Format
// Version 0.11
// Written by: Hubert Léveillé Gauvin
// Date: January - February 2022

// NOTE: 	GRACE NOTES ARE NOT SUPPORTED AT THE MOMENT (they are ignored by NoteRestAtBarPosVoice)


clefDictionary = CreateClefDictionary();
instrumentDictionary = CreateInstrumentDictionary();
keySignatureDictionary = CreateKeySignatureDictionary();
specialBarlineDictionary = CreateSpecialBarlineDictionary();
durationDictionary = CreateDurationDictionary();
pitchDictionary = CreatePitchDictionary();
articulationDictionary = CreateArticulationDictionary();

openArticulationReferenceNeeded = false;  // keep track whether needed to add !!!RDF**kern: o = harmonic/open to output. See CreateArticulationDictionary and ConvertArticulation for details.
closedArticulationReferenceNeeded = false;	// keep track whether needed to add !!!RDF**kern: O = plus/closed to output. See CreateArticulationDictionary and ConvertArticulation for details.



	// create array to track ongoing ties
	/*
	In humdrum, ties have two or three elements: Beginning and End, with maybe Middle. Thus, when note.IsTied = true, we need to track where this tie ends.
	In this array, we will store ongoing ties, i.e. ties that have been started but not yet terminated.
	On going ties are identified using a unique code, following this syntax: StaffNumber_VoiceNumber_humPitchToken. Thus  middle c in staff 2 voice 3 will be '2_3_c'.
	*/
	ongoingTiesArray = CreateSparseArray();		


thisScore = Sibelius.ActiveScore;
sysStaff = thisScore.SystemStaff;
barlines = thisScore.Barlines;
// Create blank text file

fname = '';	
fname = Sibelius.GetDocumentsFolder();
fname = fname & 'sib2humtest.krn';
Sibelius.CreateTextFile(fname);

// Get info from File > Score Info, reformat for Humdrum and append to file
AppendScoreInfoToFile(fname);


// Add Exclusive interpretations

/* Assume for the moment that everything **kern */


humExclusiveInterpretationsLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{	
s = thisScore.NthStaff(currentStaff);
		humExclusiveInterpretationsLine = humExclusiveInterpretationsLine &  '\*\*kern' & '\t';
	currentStaff = currentStaff-1;
}

humExclusiveInterpretationsLine = TrimTabsLeading(humExclusiveInterpretationsLine,false);


// Add Exclusive interpretations to krn file
Sibelius.AppendLineToFile(fname,humExclusiveInterpretationsLine);	


// Get name of instruments

humInstrumentLine = '';
humInstrumentNameFirstSystemLine = '';
humInstrumentNameSubSytemLine = '';
currentStaff = thisScore.StaffCount;
currentNumberOfVoices = CreateSparseArray(); 
while (currentStaff>0)
{	
s = thisScore.NthStaff(currentStaff);

currentNumberOfVoices[currentStaff] = 1;  // when we start, all number of voices need to be set 1 per staff. This is before measure 1 in Humdrum

		humInstrumentLine = humInstrumentLine &  ConvertInstrumentCode(s.InitialStyleId,instrumentDictionary) & '\t';
		humInstrumentNameFirstSystemLine = humInstrumentNameFirstSystemLine  & '*I' & Chr(34) & s.FullInstrumentName & '\t';
		humInstrumentNameSubSytemLine = humInstrumentNameSubSytemLine  & '*I\'' & s.ShortInstrumentName & '\t';
	
	currentStaff = currentStaff-1;
}

humInstrumentLine = TrimTabsLeading(humInstrumentLine,false);
humInstrumentNameFirstSystemLine = TrimTabsLeading(humInstrumentNameFirstSystemLine,false);
humInstrumentNameSubSytemLine = TrimTabsLeading(humInstrumentNameSubSytemLine,false);

//Add Humdrum Instrument Line to krn file
Sibelius.AppendLineToFile(fname,humInstrumentLine);
Sibelius.AppendLineToFile(fname,humInstrumentNameFirstSystemLine);
Sibelius.AppendLineToFile(fname,humInstrumentNameSubSytemLine);

// Convert Inital clef name
humInitialClefLine = '';
currentClef = CreateSparseArray();

currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);

currentClef[currentStaff] = ConvertClef(s.InitialClefStyleId,clefDictionary);	

		humInitialClefLine = humInitialClefLine &  ConvertClef(s.InitialClefStyleId,clefDictionary) & '\t';
		
	currentStaff = currentStaff-1;
}

humInitialClefLine = TrimTabsLeading(humInitialClefLine,false);

//Add Humdrum Clef Line to krn file
Sibelius.AppendLineToFile(fname,humInitialClefLine);


// Convert Initial Key Signature
initialKeySignature = thisScore.SystemStaff.InitialKeySignature.Sharps;
currentKeySignature = initialKeySignature;
humInitialKeySignatureLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);
	
		if (ConvertClef(s.InitialClefStyleId,clefDictionary) = '*clefX' )   // if clef is percussion, no key sig
		{
		humInitialKeySignatureLine = humInitialKeySignatureLine & '*' & '\t';	
		} else {
		humInitialKeySignatureLine = humInitialKeySignatureLine & ConvertKeySignature(initialKeySignature,keySignatureDictionary) & '\t';	
		}
		
	currentStaff = currentStaff-1;
}

humInitialKeySignatureLine = TrimTabsLeading(humInitialKeySignatureLine,false);

//Add Humdrum Initial Key Signature Line to krn file
Sibelius.AppendLineToFile(fname,humInitialKeySignatureLine);

// Convert Initial Time Signature

initialTimeSignature = thisScore.SystemStaff.CurrentTimeSignature(1);
currentTimeSignature = initialTimeSignature;
humInitialTimeSignatureLine = '';


initialTimeSignatureArray = ConvertTimeSignature(initialTimeSignature.Numerator,initialTimeSignature.Denominator,initialTimeSignature.Text);
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff);

		humInitialTimeSignatureLine = humInitialTimeSignatureLine & initialTimeSignatureArray[0] & '\t';
		
	currentStaff = currentStaff-1;
}

humInitialTimeSignatureLine = TrimTabsLeading(humInitialTimeSignatureLine,false);

//Add Humdrum Initial Time Signature Line to krn file
Sibelius.AppendLineToFile(fname,humInitialTimeSignatureLine);

//Check if meter info exists (e.g. common-time), and if so add to krn file

if (initialTimeSignatureArray[1] != '')
{
humInitialMeterLine = '';
currentStaff = thisScore.StaffCount;
while (currentStaff>0)
{
s = thisScore.NthStaff(currentStaff); 
	
		humInitialMeterLine = humInitialMeterLine & initialTimeSignatureArray[1] & '\t';
			
	currentStaff = currentStaff-1;
}

humInitialMeterLine = TrimTabsLeading(humInitialMeterLine,false);

//Add Humdrum Initial Meter Line to krn file
Sibelius.AppendLineToFile(fname,humInitialMeterLine);

}


// Create a humline with the barline before First Measure
// According to C.Sapp, 'Labeling the first bar is necessary if you need to extract it by measure number with a tool such as myank.'

nextExternalBarNumber = sysStaff.NthBar(1).ExternalBarNumberString;
x = 1;

sblCount = 1;
startsWithRepeat = false;


// this is not elegant, but basically see if there's a start repeat in bar 1
for each SpecialBarline sbl in sysStaff.NthBar(1)
	{
		if (sblCount = 1)
		{	
			if (sbl.BarlineInternalType = SpecialBarlineStartRepeat)
			{
			startsWithRepeat = true;
			startRepeat = sbl.BarlineInternalType;
			}
		}
	}



if (nextExternalBarNumber = '')
{
	if (startsWithRepeat = false)
	{
	thisMeasureBarline = '=-';
	} else {
	thisMeasureBarline = '=' & '1' & ConvertSpecialBarlineCode(startRepeat,specialBarlineDictionary);
	}
} else {
	if (startsWithRepeat = false)
	{
	thisMeasureBarline = '=' & 	nextExternalBarNumber;
	} else {
	thisMeasureBarline = '=' & 	nextExternalBarNumber & ConvertSpecialBarlineCode(startRepeat,specialBarlineDictionary);
	}
}

humBarlineLine = '';
currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);
		
		humBarlineLine = humBarlineLine & thisMeasureBarline & '\t';
			
	currentStaff = currentStaff-1;
	}

humBarlineLine = TrimTabsLeading(humBarlineLine,false);

//Add Humdrum Barline Line to krn file
Sibelius.AppendLineToFile(fname,humBarlineLine);


// prepare progress bar
firstbarnum = 1;
lastbarnum = thisScore.SystemStaff.BarCount;
thisScore.Redraw = False;
progress = 0;
totalBars = lastbarnum;
Sibelius.CreateProgressDialog('Converting to Humdrum format', firstbarnum, totalBars); 


addNewKeySignature = false;
addNewTimeSignature = false;
wholeBarRestTrackerArray = ResetWholeBarRestTracker();  
thisBarNumberOfVoices = CreateSparseArray();
voiceNumberArray = CreateSparseArray();
for each Bar b in sysStaff
{
	//for progress bar
	continue = Sibelius.UpdateProgressDialog(progress,'');	
	if (continue = False)
	{
		Sibelius.DestroyProgressDialog();	
		thisScore.Redraw = True;
		return False;
	}
	progress = progress + 1;	



currentInternalBarNumber = b.BarNumber;
	if (b.BarNumber < sysStaff.BarCount) // As long as not on the last bar
	{
	nextInternalBarNumber = currentInternalBarNumber+1;
	nextExternalBarNumber = sysStaff.NthBar(nextInternalBarNumber).ExternalBarNumberString; 
	}	
	
	noteRestPositionArray = CreateSparseArray();
	currentStaff = thisScore.StaffCount;
	

	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);	
	voiceNumberArray = CreateSparseArray();	

		//get a list of all the unique NoteRest position for this bar, regardless of the staff
	
		for each BarObject in s.NthBar(currentInternalBarNumber)
		{
		
		
		
			voiceNumberArray[voiceNumberArray.Length] = BarObject.VoiceNumber ; // keep track of all voice number to later identify the largest one
		
			if (BarObject.Type = 'BarRest')
			{
				if (BarObject.RestType = '0') // if RestType = WholeBarRest
				{					
				wholeBarRestTrackerArray[currentStaff] = true ; // set the tracker for this staff to true
				
					if (utils.IsInArray(noteRestPositionArray,0) = false) //add if 0 not already in array
					{
					noteRestPositionArray[noteRestPositionArray.Length] = 0;  // Create an 'event' at position 0, and add it at the end of the array. Because array iteration starts at 0, Length is the equivalent of one after last item
					}
				}
			} else {
				if (BarObject.Type = 'NoteRest')
				{
					if (utils.IsInArray(noteRestPositionArray,BarObject.Position) = false) //add if not already in array
					{	
					noteRestPositionArray[noteRestPositionArray.Length] = BarObject.Position;
					}
				}
			}	
		}
		
		//sort the array, reverse it and get the first item, i.e. the largest number of voices.
		voiceNumberArray = utils.SortArrayNumeric(voiceNumberArray,false);
		numberOfVoices = voiceNumberArray[voiceNumberArray.Length-1] ;
		thisBarNumberOfVoices[currentStaff] = numberOfVoices;
			

	
	currentStaff=currentStaff-1;	
	}
	

	
	
	
	
		// test if the time sig for this element is different than current.
		if( currentTimeSignature.Text != sysStaff.CurrentTimeSignature(currentInternalBarNumber).Text)
		{	currentTimeSignature = thisScore.SystemStaff.CurrentTimeSignature(currentInternalBarNumber);
			addNewTimeSignature = true;
		
		
		

		humNewTimeSignatureLine = '';
		currentTimeSignatureArray = ConvertTimeSignature(currentTimeSignature.Numerator,currentTimeSignature.Denominator,currentTimeSignature.Text);

		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)
		{
		s = thisScore.NthStaff(currentStaff);	
		v = currentNumberOfVoices[currentStaff] ;		
		
		while (v>0)
			{	
		
			humNewTimeSignatureLine = humNewTimeSignatureLine & currentTimeSignatureArray[0] & '\t';
			
			v = v-1;			
			}	
				
		currentStaff = currentStaff-1;
		}
		
		humNewTimeSignatureLine = TrimTabsLeading(humNewTimeSignatureLine,false);
		
		//Add Humdrum New Time Signature Line to krn file
		Sibelius.AppendLineToFile(fname,humNewTimeSignatureLine);
		
		
		//Check if meter info exists (e.g. common-time), and if so add to krn file
		humNewMeterLine = '';
		if (currentTimeSignatureArray[1] != '')
		{

		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)
		{
		s = thisScore.NthStaff(currentStaff);	
		v = currentNumberOfVoices[currentStaff] ;		
		
		while (v>0)
			{	
			
			
			
			humNewMeterLine = humNewMeterLine & currentTimeSignatureArray[1] & '\t';
		
			v = v-1;			
			}	
		
			currentStaff = currentStaff-1;
		}

		humNewMeterLine = TrimTabsLeading(humNewMeterLine,false);

		//Add Humdrum Initial Meter Line to krn file
		Sibelius.AppendLineToFile(fname,humNewMeterLine);

		}

		
		
		
		}
	
	
	
	// check to see if the number of voices has changed between this bar and last bar
	keepLooping = true;
	writeHumSpinePathLineToFile = false;
	while (keepLooping=true)
	{
		keepLoopingArray = CreateSparseArray();
		keepLooping = false;
		
		currentStaff = thisScore.StaffCount;
		writeHumSpinePathLineToFile = false;
		humSpinePathLine = '';
		alreadyRemovedASpine = false;
	while (currentStaff>0)  //for each staff
		{
		
	
			if (thisBarNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff])
			{
			
				for x = 0 to thisBarNumberOfVoices[currentStaff]
				{
					
					humSpinePathLine = 	humSpinePathLine & '*' & '\t' ;
					
				}	
			} else {
				writeHumSpinePathLineToFile = true;
				if (thisBarNumberOfVoices[currentStaff] > currentNumberOfVoices[currentStaff])  //if we need to add a spine
				{
						
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]+1) & '\t' ;
						
					currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]+1 ;

					
					
				} else {  //if we need to remove a spine
						
						
						if (alreadyRemovedASpine = true)
						{
						
								for x = 0 to currentNumberOfVoices[currentStaff]
								{
					
								humSpinePathLine = 	humSpinePathLine & '*' & '\t' ;
					
								}	
						
						} else {	
						

						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) & '\t' ;

						currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]-1 ;
						alreadyRemovedASpine = true;
						}
				}		
				
			}
			
			
			if (thisBarNumberOfVoices[currentStaff] != currentNumberOfVoices[currentStaff])
				{
					keepLoopingArray[keepLoopingArray.Length] = 'true';	
				} else {
					keepLoopingArray[keepLoopingArray.Length] = 'false';
				}	
	
		
		
		
		currentStaff=currentStaff-1;	
		}
	
		for each i in keepLoopingArray 
			{
				if (i='true')
				{ 
				keepLooping = true;
				}
			}
	
		
		if (writeHumSpinePathLineToFile = true)
		{
			humSpinePathLine  = TrimTabsLeading(humSpinePathLine,false);
			Sibelius.AppendLineToFile(fname,humSpinePathLine);
		}
		
		
	}
	
	
	
	
	
	
	
	// sort the array
	noteRestPositionArray = utils.SortArrayNumeric(noteRestPositionArray,false);
	
	
	

	
	
	// create one humLine per Rhythmic Position in noteRestPositionArray
	line = '1';
	
	for each e in noteRestPositionArray
	{
	
	/* 	I think the loop for grace note should go here	
		but I'm not sure how to go about it.	
	*/	
	
	
	writeNewClefArray = CreateSparseArray();
	newClefNeeded = false;
	humLine = '';
	
		// test if the key sig for this element is different than current.
		// NOTE: This method assumes that all staves have same key signature, which might not always be true...
		if( currentKeySignature != b.GetKeySignatureAt(e).Sharps)
		{	currentKeySignature = b.GetKeySignatureAt(e).Sharps;
			addNewKeySignature = true;
		}
		
		
	
			currentStaff = thisScore.StaffCount;
			while (currentStaff>0) // for each staff, but reverse order...
			{
			s = thisScore.NthStaff(currentStaff);	
			v = currentNumberOfVoices[currentStaff] ;	
			
			// Store the clef at this staff/pos to compare later with currentClef 
			clefObject = s.NthBar(currentInternalBarNumber).GetClefAt(e);
			
			if (ConvertClef(clefObject.ConcertClefStyleId,clefDictionary) != currentClef[currentStaff]) // if the clef for this staff has changed
			{

			writeNewClefArray[currentStaff] = ConvertClef(clefObject.ConcertClefStyleId,clefDictionary);
			currentClef[currentStaff] = ConvertClef(clefObject.ConcertClefStyleId,clefDictionary);
			newClefNeeded = true;
			} else {

				writeNewClefArray[currentStaff] = 'false';	
			}
			
			while (v>0)
			{	
				
				if (wholeBarRestTrackerArray[currentStaff] = true)  // if this measure is wholebarrest
				{
					
			
						kernToken = 'rr' & '\t';
					
					wholeBarRestTrackerArray[currentStaff] = false ;
				} else {
					
					result = NoteRestAtBarPosVoice(s.NthBar(currentInternalBarNumber),e,v); 
					kernToken = '' ;
					if (result != null)
					{
					humDuration = ConvertDuration(result,durationDictionary);
						if (result.NoteCount = 0)   // is NoteRest is rest
						{
							
							if (result.Hidden = true)
							{
							kernToken = humDuration & 'ryy' & '\t';	//yy means invisible
							} else {
							kernToken = humDuration & 'r' & '\t';
							}
							
						} else {// if NoteRest is note or chord
						

							for each n in result  // for each note of chord
							{	
							
							

					
								continueOrEndTieOutputArray = ContinueOrEndTie(n,ongoingTiesArray,currentStaff,v,pitchDictionary);
								humEndToken = continueOrEndTieOutputArray[0];		
								
								articulationArray = ConvertArticulation(n,articulationDictionary);
								humArticulation = articulationArray[0];
								kernToken = kernToken & BeginTie(n,ongoingTiesArray,currentStaff,v,pitchDictionary) & humDuration & ConvertPitch(n,pitchDictionary) & humArticulation & humEndToken & ' ';  
									
								ongoingTiesArray = AddToOngoiontTiesArray(n,ongoingTiesArray,currentStaff,v,pitchDictionary);
							
								
								tieUniqueCode = continueOrEndTieOutputArray[1] ;
								removeTieUniqueCode = continueOrEndTieOutputArray[2];
								if (removeTieUniqueCode = true)
								{
									ongoingTiesArray = RemoveFromSparseArray(tieUniqueCode,ongoingTiesArray);
								}
							
							}
							
							
							kernToken = utils.TrimBlanks(kernToken) & '\t';  // Remove that last space that was added in the loop above AND ADD tab 
							
						
						
				
							
						
							if (articulationArray[1] = true) // if openArticualationReferenceNeeded
							{
							openArticulationReferenceNeeded = true; 
							}
							
							if (articulationArray[2] = true) // if closedArticualationReferenceNeeded
							{
							closedArticulationReferenceNeeded = true;	
							}
						
						
						}

				
						
				
				

					} else { // if there is no event at that position in that bar, null token is needed
					
					
						kernToken = '.' & '\t';	
		
					
					}
				}
				
				humLine = humLine & kernToken;
					 
				v = v-1;
			}	
				currentStaff = currentStaff-1;
			}
		
		 
		 
		 
		 // if addNewKeySignature is true, add a new key signature before adding Humdrum Line 
		if (addNewKeySignature = true)
		{
			
			humNewKeySignatureLine = '';
			currentStaff = thisScore.StaffCount;
			while (currentStaff>0)
			{
			s = thisScore.NthStaff(currentStaff);
			v = currentNumberOfVoices[currentStaff] ;			
			
				while (v>0)
				{
				
					
							if (currentClef[currentStaff] = '*clefX' )   // if clef is percussion, no key sig
							{
							humNewKeySignatureLine = humNewKeySignatureLine & '*' & '\t';	
							} else {
							humNewKeySignatureLine = humNewKeySignatureLine & ConvertKeySignature(currentKeySignature,keySignatureDictionary) & '\t';	
							}
							
				
				v = v-1;
				}	
			
			currentStaff = currentStaff-1;
			}	

		
			humNewKeySignatureLine = TrimTabsLeading(humNewKeySignatureLine,false);
			
			//Add New Key Signature Line to krn file
			Sibelius.AppendLineToFile(fname,humNewKeySignatureLine);
			addNewKeySignature = false ; // set back flag to false
		}
		 
		 
		 // check if a staff has a new clef, and if so, add new Clef Line befor main humLine
		if (newClefNeeded = true) // if something was added to the array, this means we need a new clef somewhere
		{

			currentStaff = thisScore.StaffCount;
			humNewClefLine = '';
			while (currentStaff>0) // for each staff, but reverse order...
			{
			s = thisScore.NthStaff(currentStaff);	
			v = currentNumberOfVoices[currentStaff];
				while (v>0)
				{	
			
				
						if (writeNewClefArray[currentStaff] != 'false')
						{	
							humNewClefLine = humNewClefLine & writeNewClefArray[currentStaff] & '\t';
						} else {
							humNewClefLine = humNewClefLine & '\*' & '\t';
						}
						

				v = v-1;
				}	
			currentStaff = currentStaff-1;
			}
			
		
		humNewClefLine = TrimTabsLeading(humNewClefLine,false);
		
		//Add Humdrum Line to krn file
		Sibelius.AppendLineToFile(fname,humNewClefLine);	
		}
		 
		 
		
		humLine = TrimTabsLeading(humLine,false);
		
		//Add Humdrum Line to krn file
		Sibelius.AppendLineToFile(fname,humLine);


	line = line+1;	
	}	
	
	
	/* 	This bit is a train wreck, because of the different way in which Sib and Humdrum handle barlines. 
		The complicated bit is the end-repeat-start-repeat combinaision.
		I need to look at special barlines always for the current and next barline 
	*/
	
	specialBarline = false;
	thisMeasureBarline = '';
	x=1;
	for each SpecialBarline sbl in b	
	{
	specialBarline = true;
	
		if (b.BarNumber = sysStaff.BarCount)
		{

		thisMeasureBarline = '=' & ConvertSpecialBarlineCode(sbl.BarlineInternalType,specialBarlineDictionary);  // if final barline, no bar number
		} else {
				
				
				if (startsWithRepeat = true)
				{ 
				startsWithRepeat = false;
				specialBarline = false;
				} else {
				thisMeasureBarline = '=' & nextExternalBarNumber & ConvertSpecialBarlineCode(sbl.BarlineInternalType,specialBarlineDictionary) & CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber);
				thisMeasureBarline = utils.Replace(thisMeasureBarline,'!!','!',false); // when there is end repeat followed by start repeat, this removes the superfluous !
					if (CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) != '')
					{
					startsWithRepeat = true;
					} else {
					startsWithRepeat = false;
					}
				}
		}			
	x=x+1;
	}

	if (specialBarline = false)
	{
			if (b.BarNumber = sysStaff.BarCount)
			{
			thisMeasureBarline = '=' ;  //in the rare case where last measure does not have a special barline, make sure to not add a bar number
			} else {
			
			thisMeasureBarline = '=' & nextExternalBarNumber & CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) ;
			thisMeasureBarline = utils.Replace(thisMeasureBarline,'!!','!',false); 
				if (CreateTokenIfBarStartsWithStartRepeat(nextInternalBarNumber) != '')
					{
					startsWithRepeat = true;
					} else {
					startsWithRepeat = false;
					}
			}

	}

	// Create a humline with the barline at the end of this measure

	humBarlineLine = '';
	
	currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff); 
		
		
			v = currentNumberOfVoices[currentStaff] ;
			while (v>0)
			{	
				
				
				humBarlineLine = humBarlineLine & thisMeasureBarline & '\t';
					
			v = v-1;
			}
		
		currentStaff = currentStaff-1;
	}

	
	
	
	humBarlineLine = TrimTabsLeading(humBarlineLine,false);
	
		
	//Add Humdrum Barline Line to krn file
	Sibelius.AppendLineToFile(fname,humBarlineLine);


}


// bring the number of spines to 1 per staff before spine-terminator

	keepLooping = true;
	writeHumSpinePathLineToFile = false;
	while (keepLooping=true)
	{
		keepLoopingArray = CreateSparseArray();
		keepLooping = false;
		humSpinePathLine = '';
		currentStaff = thisScore.StaffCount;
		while (currentStaff>0)  //for each staff
		{
			if (currentNumberOfVoices[currentStaff] = 1)
			{
				for x = 0 to currentNumberOfVoices[currentStaff]
				{
					
					humSpinePathLine = 	humSpinePathLine & '*' & '\t' ;
					
				}
			} else {  //if we need to remove a spine
			writeHumSpinePathLineToFile = true;
			
						
						humSpinePathLine = 	humSpinePathLine &  CreateSpinePathIndicators(currentNumberOfVoices[currentStaff],currentNumberOfVoices[currentStaff]-1) & '\t' ;
					
					
					currentNumberOfVoices[currentStaff] = currentNumberOfVoices[currentStaff]-1 ;
			}		
				
			
			
			if (currentNumberOfVoices[currentStaff] != 1)
				{
					keepLoopingArray[keepLoopingArray.Length] = 'true';	
				} else {
					keepLoopingArray[keepLoopingArray.Length] = 'false';
				}	
	
		currentStaff=currentStaff-1;	
		}
	
		for each i in keepLoopingArray 
			{
				if (i='true')
				{ 
				keepLooping = true;
				}				
			}
	
	
		if (writeHumSpinePathLineToFile = true)
		{
			humSpinePathLine = TrimTabsLeading(humSpinePathLine,false);
			Sibelius.AppendLineToFile(fname,humSpinePathLine);
		}
	}












	// create one Humdrum spine-path terminator Line

	humSpinePathTerminatorLine = '';
	currentStaff = thisScore.StaffCount;
	while (currentStaff>0)
	{
	s = thisScore.NthStaff(currentStaff);	
	
		humSpinePathTerminatorLine = humSpinePathTerminatorLine & '*-' & '\t';
			
		currentStaff = currentStaff-1;
	}

	
humSpinePathTerminatorLine = TrimTabsLeading(humSpinePathTerminatorLine,false);
	
	
//Add Humdrum spine-path terminator Line to krn file
Sibelius.AppendLineToFile(fname,humSpinePathTerminatorLine);
	
// for progress bar
Sibelius.DestroyProgressDialog();	
thisScore.Redraw = True;


// Add !!!RDF**kern: o = harmonic/open if needed
if (openArticulationReferenceNeeded = true)
{
Sibelius.AppendLineToFile(fname,'!!!RDF**kern: o = harmonic/open');	
}

// Add !!!RDF**kern: O = plus/closed if needed
if (closedArticulationReferenceNeeded = true)
{
Sibelius.AppendLineToFile(fname,'!!!RDF**kern: O = plus/closed');	
}


//Add final line that doesn't end with new line car, hence AppendTextFile and not AppendLineToFile
Sibelius.AppendTextFile(fname,'!! Converted from Sibelius with sib2hum plugin');


	


//Message Box at the end to know it's done is nice
Sibelius.MessageBox('Done! The file is available here; ' & fname);



}"
	ConvertInstrumentCode "(InitialStyleId,instrumentDictionary) {
/* Instruments that are not currently mapped to a Humdrum equivalent will become **I?? for the moment */


if (instrumentDictionary[InitialStyleId] = '')
{
return '*I??';
} else {
return instrumentDictionary[InitialStyleId];
}}"
	ConvertClef "(clefStyle,clefDictionary) {
/* Convert Sib clefs to Humdrum format using the dictionary createde with CreateClefDictionary() ; 
I'm ignoring all TAB clefs for the moment; they will become *clef?? */


if (clefDictionary[clefStyle] = '')
{
return '*clef??';
} else {
return clefDictionary[clefStyle];
}

}"
	CreateInstrumentDictionary "() {
instrumentDictionary = CreateDictionary(

'instrument.brass.cornet.a','*Icornt',
'instrument.brass.cornet.bflat','*Icornt',
'instrument.brass.cornet.soprano.eflat','*Icornt',
'instrument.brass.flugelhorn','*Iflugh',
'instrument.brass.horn.a.nokeysig','*Icor',
'instrument.brass.horn.alto.aflat.nokeysig','*Icor',
'instrument.brass.horn.alto.eflat','*Icor',
'instrument.brass.horn.alto.f','*Icor',
'instrument.brass.horn.b.nokeysig','*Icor',
'instrument.brass.horn.basso.a.nokeysig','*Icor',
'instrument.brass.horn.basso.bflat.nokeysig','*Icor',
'instrument.brass.horn.basso.c.nokeysig','*Icor',
'instrument.brass.horn.bflat.nokeysig','*Icor',
'instrument.brass.horn.c.nokeysig','*Icor',
'instrument.brass.horn.d.nokeysig','*Icor',
'instrument.brass.horn.dflat.nokeysig','*Icor',
'instrument.brass.horn.e.nokeysig','*Icor',
'instrument.brass.horn.eflat','*Icor',
'instrument.brass.horn.eflat.nokeysig','*Icor',
'instrument.brass.horn.f','*Icor',
'instrument.brass.horn.f.bassclef','*Icor',
'instrument.brass.horn.f.nokeysig','*Icor',
'instrument.brass.horn.fsharp.nokeysig','*Icor',
'instrument.brass.horn.g.nokeysig','*Icor',
'instrument.brass.horn.tenor','*Icor',
'instrument.brass.trombone','*Itromt',
'instrument.brass.trombone.bassclef.trebleclef','*Itromt',
'instrument.brass.trombone.tenor','*Itromt',
'instrument.brass.trombone.trebleclef','*Itromt',
'instrument.brass.trumpet.a','*Itromp',
'instrument.brass.trumpet.b.nokeysig','*Itromp',
'instrument.brass.trumpet.bflat','*Itromp',
'instrument.brass.trumpet.bflat.nokeysig','*Itromp',
'instrument.brass.trumpet.c','*Itromp',
'instrument.brass.trumpet.d','*Itromp',
'instrument.brass.trumpet.dflat','*Itromp',
'instrument.brass.trumpet.e.nokeysig','*Itromp',
'instrument.brass.trumpet.eflat','*Itromp',
'instrument.brass.trumpet.f','*Itromp',
'instrument.brass.trumpet.g.nokeysig','*Itromp',
'instrument.brass.tuba','*Ituba',
'instrument.brass.tuba.f','*Ituba',
'instrument.brass.tuba.tenor','*Ituba',
'instrument.brass.tuba.tenor.bassclef','*Ituba',
'instrument.brass.tuba.wagner.bflat','*Ituba',
'instrument.brass.tuba.wagner.f','*Ituba',
'instrument.fretted.banjo.5lines','*Ibanjo',
'instrument.fretted.banjo.aDADE.tab','*Ibanjo',
'instrument.fretted.banjo.aEADE.tab','*Ibanjo',
'instrument.fretted.banjo.gCGBD.tab','*Ibanjo',
'instrument.fretted.banjo.gCGCD.tab','*Ibanjo',
'instrument.fretted.banjo.gDFAD.tab','*Ibanjo',
'instrument.fretted.banjo.gDGBD.tab','*Ibanjo',
'instrument.fretted.banjo.gDGCD.tab','*Ibanjo',
'instrument.fretted.banjo.tenor.5lines','*Ibanjo',
'instrument.fretted.banjo.tenor.tab','*Ibanjo',
'instrument.fretted.guitar.resonator.5lines','*Iguitr',
'instrument.fretted.guitar.resonator.a6.tab','*Iguitr',
'instrument.fretted.guitar.resonator.b11.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c#m.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6-a7.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6-highg.tab','*Iguitr',
'instrument.fretted.guitar.resonator.c6.tab','*Iguitr',
'instrument.fretted.guitar.resonator.cm7.tab','*Iguitr',
'instrument.fretted.guitar.resonator.e13-hawaiian.tab','*Iguitr',
'instrument.fretted.guitar.resonator.e13-western.tab','*Iguitr',
'instrument.fretted.guitar.resonator.open.A.tab','*Iguitr',
'instrument.fretted.guitar.resonator.open.G.tab','*Iguitr',
'instrument.fretted.dulcimer','*Idulc',
'instrument.fretted.dulcimer.5lines','*Idulc',
'instrument.fretted.dulcimer.daa.tab','*Idulc',
'instrument.fretted.dulcimer.dad.tab','*Idulc',
'instrument.fretted.guitar.12-string.5lines','*Iguitr',
'instrument.fretted.guitar.12-string.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.12-string.double-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-d.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-e.tab','*Iguitr',
'instrument.fretted.guitar.12-string.open-g.tab','*Iguitr',
'instrument.fretted.guitar.12-string.tab','*Iguitr',
'instrument.fretted.guitar.12-string.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.acoustic.5lines','*Iguitr',
'instrument.fretted.guitar.acoustic.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.double-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.modal-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.nashville.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-a.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-c.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-d.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-dm.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-e.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.open-g.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.tab','*Iguitr',
'instrument.fretted.guitar.acoustic.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.bass.4-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.4-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.5lines','*Ibguit',
'instrument.fretted.guitar.bass.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.fretless.tab','*Ibguit',
'instrument.fretted.guitar.bass.electric.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.6-string.5lines','*Ibguit',
'instrument.fretted.guitar.bass.fretless.6-string.tab','*Ibguit',
'instrument.fretted.guitar.bass.fretless.tab','*Ibguit',
'instrument.fretted.guitar.bass.semi-acoustic.5lines','*Ibguit',
'instrument.fretted.guitar.bass.semi-acoustic.tab','*Ibguit',
'instrument.fretted.guitar.bass.tab','*Ibguit',
'instrument.fretted.guitar.bass.tab.rhythms','*Ibguit',
'instrument.fretted.guitar.classical.5lines','*Iguitr',
'instrument.fretted.guitar.classical.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.classical.double-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-d.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-e.tab','*Iguitr',
'instrument.fretted.guitar.classical.open-g.tab','*Iguitr',
'instrument.fretted.guitar.classical.tab','*Iguitr',
'instrument.fretted.guitar.classical.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.electric.5lines','*Ieguit',
'instrument.fretted.guitar.electric.7-string.low-a.tab','*Ieguit',
'instrument.fretted.guitar.electric.7-string.tab','*Ieguit',
'instrument.fretted.guitar.electric.dadgad.tab','*Ieguit',
'instrument.fretted.guitar.electric.double-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.dropped-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-d.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-e.tab','*Ieguit',
'instrument.fretted.guitar.electric.open-g.tab','*Ieguit',
'instrument.fretted.guitar.electric.tab','*Ieguit',
'instrument.fretted.guitar.electric.tab.rhythms','*Ieguit',
'instrument.fretted.guitar.semi-acoustic.5lines','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.dadgad.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.double-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.dropped-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-d.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-e.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.open-g.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.tab','*Iguitr',
'instrument.fretted.guitar.semi-acoustic.tab.rhythms','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.10-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.5lines','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.alternative','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.bflat.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.c.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.cgdgbd.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.cgdgbe.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.dgdfbd.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.g.mauna.loa','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.g.taro.patch','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.6-string.tab.gcdgbe.wahine','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.8-string.tab','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.8-string.tab.alternative','*Iguitr',
'instrument.fretted.guitar.steel.hawaiian.tab','*Iguitr',
'instrument.fretted.guitar.steel.pedal.5lines','*Iguitr',
'instrument.fretted.guitar.steel.pedal.tab','*Iguitr',
'instrument.fretted.guitarra.5lines','*Iguitr',
'instrument.fretted.guitarra.coimbra.tab','*Iguitr',
'instrument.fretted.guitarra.lisboa.tab','*Iguitr',
'instrument.fretted.guitarra.portuguesa.tab','*Iguitr',
'instrument.fretted.lute.5lines','*Iliuto',
'instrument.fretted.lute.bass-d.french.english.5lines','*Iliuto',
'instrument.fretted.lute.bass-d.french.english.tab','*Iliuto',
'instrument.fretted.lute.bass-d.italian.tab','*Iliuto',
'instrument.fretted.lute.bass-d.spanish.tab','*Iliuto',
'instrument.fretted.lute.italian.tab','*Iliuto',
'instrument.fretted.lute.spanish.tab','*Iliuto',
'instrument.fretted.lute.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.french.english.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.italian.tab','*Iliuto',
'instrument.fretted.lute.tenor-a.spanish.tab','*Iliuto',
'instrument.fretted.lute.treble-d.french.english.5lines','*Iliuto',
'instrument.fretted.lute.treble-d.french.english.tab','*Iliuto',
'instrument.fretted.lute.treble-d.italian.tab','*Iliuto',
'instrument.fretted.lute.treble-d.spanish.tab','*Iliuto',
'instrument.fretted.mandolin.5lines','*Imando',
'instrument.fretted.mandolin.tab','*Imando',
'instrument.fretted.oud.5lines','*Ioud',  // 2022-01-30: New instrument code proposed by C.Sapp to replace old Iud
'instrument.fretted.oud.tab','*Ioud',	// 2022-01-30: New instrument code proposed by C.Sapp to replace old Iud
'instrument.fretted.sitar.5lines','*Isitar',
'instrument.fretted.sitar.ravi-shankkar.tab','*Isitar',
'instrument.fretted.sitar.vilayat-khan.tab','*Isitar',
'instrument.fretted.tambura.female','*Itambu',
'instrument.fretted.tambura.male','*Itambu',
'instrument.fretted.ukulele.5lines','*Iukule',
'instrument.fretted.ukulele.tab','*Iukule',
'instrument.fretted.zither','*Izithr',
'instrument.keyboard.accordion','*Iaccor',
'instrument.keyboard.celesta','*Iclest',
'instrument.keyboard.clavichord','*Iclavi',
'instrument.keyboard.keyboards','*Icemba',
'instrument.keyboard.organ.manuals','*Iorgan',
'instrument.keyboard.organ.manuals.solo','*Iorgan',
'instrument.keyboard.organ.pedals','*Iorgan',
'instrument.keyboard.organ.pedals.solo','*Iorgan',
'instrument.keyboard.piano','*Ipiano',
'instrument.keyboard.synthesizer','*Isynth',
'instrument.pitchedpercussion.bells.chimes','*Ichime',
'instrument.pitchedpercussion.bells.chimes.nokeysig','*Ichime',
'instrument.pitchedpercussion.bells.orchestral','*Icampn',
'instrument.pitchedpercussion.bells.tubular','*Icampn',
'instrument.pitchedpercussion.cimbalom','*Idulc',
'instrument.pitchedpercussion.drums.steel','*Isteel',
'instrument.pitchedpercussion.drums.steel.bassclef','*Isteel',
'instrument.pitchedpercussion.glockenspiel','*Iglock',
'instrument.pitchedpercussion.glockenspiel.alto','*Iglock',
'instrument.pitchedpercussion.glockenspiel.soprano','*Iglock',
'instrument.pitchedpercussion.harp','*Iarpa',
'instrument.pitchedpercussion.harp.lever','*Iarpa',
'instrument.pitchedpercussion.timpani','*Itimpa',
'instrument.pitchedpercussion.timpani.nokeysig','*Itimpa',
'instrument.pitchedpercussion.vibraphone','*Ivibra',
'instrument.pitchedpercussion.xylophone','*Ixylo',
'instrument.pitchedpercussion.xylophone.alto','*Ixylo',
'instrument.pitchedpercussion.xylophone.bass','*Ixylo',
'instrument.pitchedpercussion.xylophone.soprano','*Ixylo',
'instrument.singers.alto','*Ialto',
'instrument.singers.alto.solo','*Ialto',
'instrument.singers.baritone','*Ibarit',
'instrument.singers.baritone.solo','*Ibarit',
'instrument.singers.bass','*Ibass',
'instrument.singers.bass.solo','*Ibass',
'instrument.singers.contralto','*Icalto',
'instrument.singers.counter-tenor','*Ictenor',
'instrument.singers.mezzo-soprano','*Imezzo',
'instrument.singers.soprano','*Isoprn',
'instrument.singers.soprano.solo','*Isoprn',
'instrument.singers.tenor','*Itenor',
'instrument.singers.tenor.solo','*Itenor',
'instrument.singers.voice.male','*Imale',
'instrument.strings.contrabass','*Icbass',
'instrument.strings.contrabass.bass','*Icbass',
'instrument.strings.contrabass.double-bass','*Icbass',
'instrument.strings.contrabass.solo','*Icbass',
'instrument.strings.contrabass.string','*Icbass',
'instrument.strings.contrabass.upright','*Icbass',
'instrument.strings.viola','*Iviola',
'instrument.strings.viola.solo','*Iviola',
'instrument.strings.violin.1','*Ivioln',
'instrument.strings.violin.2','*Ivioln',
'instrument.strings.violin.I','*Ivioln',
'instrument.strings.violin.ii','*Ivioln',
'instrument.strings.violin.solo','*Ivioln',
'instrument.strings.violoncello','*Icello',
'instrument.strings.violoncello.solo','*Icello',
'instrument.unpitched.drums.cymbal','*Ipiatt',
'instrument.unpitched.drums.table','*Itabla',
'instrument.unpitched.drums.tom-toms','*Itom',
'instrument.unpitched.drums.tom-toms.4lines','*Itom',
'instrument.unpitched.gong.large.1line','*Igong',
'instrument.unpitched.gong.medium.1line','*Igong',
'instrument.unpitched.tambourine','*Itambn',
'instrument.unpitched.triangle','*Itrngl',
'instrument.wind.bassoon','*Ifagot',
'instrument.wind.bassoon.quart','*Ifag_c',
'instrument.wind.clarinet.a','*Iclars',
'instrument.wind.clarinet.aflat','*Iclars',
'instrument.wind.clarinet.alto.eflat','*Iclara',
'instrument.wind.clarinet.alto.eflat.bassclef','*Iclara',
'instrument.wind.clarinet.bass.bflat','*Iclarb',
'instrument.wind.clarinet.bass.bflat.8vb-score','*Iclarb',
'instrument.wind.clarinet.bass.bflat.bassclef','*Iclarb',
'instrument.wind.clarinet.bflat','*Iclars',
'instrument.wind.clarinet.c','*Iclars',
'instrument.wind.clarinet.d','*Iclars',
'instrument.wind.clarinet.eflat','*Iclars',
'instrument.wind.clarinet.g','*Iclars',
'instrument.wind.coranglais','*Icangl',
'instrument.wind.englishhorn','*Icangl',
'instrument.wind.flute','*Iflt',
'instrument.wind.flute.alto','*Iflt_a',
'instrument.wind.flute.bansuri','*Ibansu',
'instrument.wind.flute.bass','*Iflt_b',
'instrument.wind.flute.eflat','*Iflt',
'instrument.wind.flute.g','*Iflt',
'instrument.wind.harmonica','*Iarmon',
'instrument.wind.oboe','*Ioboe',
'instrument.wind.oboe.baritone','*Ioboe',
'instrument.wind.oboe.bass','*Ioboe',
'instrument.wind.oboe.damore','*IoboeD',
'instrument.wind.ocarina','*Iocari',
'instrument.wind.piccolo','*Ipicco',
'instrument.wind.piccolo.dflat','*Ipicco',
'instrument.wind.recorder.alto','*Ifltda',
'instrument.wind.recorder.bass','*Ifltdb',
'instrument.wind.recorder.sopranino','*Ifltdn',
'instrument.wind.recorder.soprano','*Ifltds',
'instrument.wind.recorder.tenor','*Ifltdt',
'instrument.wind.saxophone.alto','*Ifltda',
'instrument.wind.saxophone.baritone','*IsaxR',
'instrument.wind.saxophone.baritone.8vb-score','*IsaxR',
'instrument.wind.saxophone.baritone.bassclef','*IsaxR',
'instrument.wind.saxophone.bass','*IsaxB',
'instrument.wind.saxophone.bass.15mb-score','*IsaxB',
'instrument.wind.saxophone.bass.bassclef','*IsaxB',
'instrument.wind.saxophone.contrabass','*IsaxC',
'instrument.wind.saxophone.contrabass.15mb-score','*IsaxC',
'instrument.wind.saxophone.contrabass.bassclef','*IsaxC',
'instrument.wind.saxophone.sopranino','*IsaxN',
'instrument.wind.saxophone.soprano','*IsaxS',
'instrument.wind.saxophone.tenor','*IsaxT',
'instrument.wind.saxophone.tenor.8vb-score','*IsaxT',
'instrument.wind.saxophone.tenor.bassclef','*IsaxT',
'instrument.wind.shakuhachi','*Ishaku');

return instrumentDictionary;}"
	CreateClefDictionary "() {
clefDictionary = CreateDictionary(
'clef.alto','*clefC3',
'clef.baritone.c','*clefC5',
'clef.baritone.f','*clefF3',
'clef.bass','*clefF4',
'clef.bass.down.8','*clefFv4',
'clef.bass.up.15','*clefF^^4',
'clef.bass.up.8','*clefF^4',
'clef.percussion','*clefX',
'clef.percussion_2','*clefX',
'clef.soprano','*clefC1',
'clef.soprano.mezzo','*clefC2',
'clef.tenor','*clefC4',
'clef.tenor.down.8','*clefCv4',
'clef.treble','*clefG2',
'clef.treble.down.8','*clefGv2',
'clef.treble.down.8.bracketed','*clefGv2',
'clef.treble.down.8.old','*clefGv2',
'clef.treble.up.15','*clefG^15',
'clef.treble.up.8','*clefG^8',
'clef.violin.french','*clefG1',
'clef.sub-bass.f','*clefF5');

return clefDictionary;}"
	AppendScoreInfoToFile "(fname) {
thisScore = Sibelius.ActiveScore;

if (thisScore.Composer != '')
{
humComposer = '!!!COM: ' & thisScore.Composer;
Sibelius.AppendLineToFile(fname,humComposer);  
}

if (thisScore.ComposerDates != '')
{
humComposerDates = '!!!CDT: ' & thisScore.ComposerDates;
Sibelius.AppendLineToFile(fname,humComposerDates);  
}

if (thisScore.Lyricist != '')
{
humLyricist = '!!!LYR: ' & thisScore.Lyricist;
Sibelius.AppendLineToFile(fname,humLyricist);  
}

if (thisScore.Arranger != '')
{
humArranger = '!!!LAR: ' & thisScore.Arranger;
Sibelius.AppendLineToFile(fname,humArranger);  
}

//Here I chose to use MPN-artist for Artist
if (thisScore.Artist != '')
{
humArtist = '!!!MPN-artist: ' & thisScore.Artist;  
Sibelius.AppendLineToFile(fname,humArtist);
}

if (thisScore.Title != '')
{
humTitle = '!!!OTL: ' & thisScore.Title; 
Sibelius.AppendLineToFile(fname,humTitle); 
}

if (thisScore.Subtitle != '')
{
humSubTitle = '!!!OTL-sub: ' & thisScore.Subtitle;  
Sibelius.AppendLineToFile(fname,humSubTitle);
}

if (thisScore.OpusNumber != '')
{
humOpusNumber = '!!!OPS: ' & thisScore.OpusNumber;  
Sibelius.AppendLineToFile(fname,humOpusNumber);
}

if (thisScore.Dedication != '')
{
humDedication = '!!!ODE: ' & thisScore.Dedication;  
Sibelius.AppendLineToFile(fname,humDedication);
}

if (thisScore.OtherInformation != '')
{
humNotaBene = '!!!ONB: ' & thisScore.OtherInformation;  
Sibelius.AppendLineToFile(fname,humNotaBene);
}


if (thisScore.YearOfComposition != '')
{
humYearOfComposition = '!!!ODT: ' & thisScore.YearOfComposition;  
Sibelius.AppendLineToFile(fname,humYearOfComposition);
}

if (thisScore.Publisher != '')
{
humPublisher = '!!!YEP: ' & thisScore.Publisher;  
Sibelius.AppendLineToFile(fname,humPublisher);
}

if (thisScore.Copyright != '')
{
	if (thisScore.Copyright != 'Copyright © ')
	{
	humCopyright = '!!!YEM: ' & thisScore.Copyright;  
	Sibelius.AppendLineToFile(fname,humCopyright);
	}
}

//Here I chose to use ENC-copyist for Copyist 
if (thisScore.Copyist != '')
{
humCopyist = '!!!ENC-copyist: ' & thisScore.Copyist;  
Sibelius.AppendLineToFile(fname,humCopyist);
}

















}"
	CreateKeySignatureDictionary "() {
keySignatureDictionary = CreateDictionary(
'-7','*k[b-e-a-d-g-c-f-]',
'-6','*k[b-e-a-d-g-c-]',
'-5','*k[b-e-a-d-g-]',
'-4','*k[b-e-a-d-]',
'-3','*k[b-e-a-]',
'-2','*k[b-e-]',
'-1','*k[b-]',
'0','*k[]',
'1','*k[f#]',
'2','*k[f#c#]',
'3','*k[f#c#g#]',
'4','*k[f#c#g#d#]',
'5','*k[f#c#g#d#a#]',
'6','*k[f#c#g#d#a#e#]',
'7','*k[f#c#g#d#a#e#b#]'


);

return keySignatureDictionary;}"
	ConvertKeySignature "(keySignature,keySignatureDictionary) {
if (keySignatureDictionary[keySignature] = '')
{
return '*k??';
} else {
return keySignatureDictionary[keySignature];
}

}"
	ConvertTimeSignature "(Numerator,Denominator,Text) {


switch(Text){
case(CommonTimeString){humTimeSignature = '*M4/4'; humMeter = '*met(c)';}
case(AllaBreveTimeString){humTimeSignature = '*M2/2'; humMeter = '*met(c|)';}
default {humTimeSignature = '*M' & Numerator & '/' & Denominator; humMeter = '';}
}

timeSignatureArray = CreateSparseArray(humTimeSignature,humMeter);

return timeSignatureArray;}"
	NotePad "() {

thisScore = Sibelius.ActiveScore;
currentStaff = thisScore.StaffCount;
s = thisScore.NthStaff(currentStaff);	



for each NoteRest nr in thisScore.NthStaff(1)
{

Sibelius.MessageBox(nr.GraceNote);
}}"
	ConvertSpecialBarlineCode "(BarlineInternalTypeID,specialBarlineDictionary) {
if (BarlineInternalTypeID = 7) // this first if is needed because specialBarlineDictionary[7] equals '' , but in that case, we don't want to return  return '=??';
{
return specialBarlineDictionary[BarlineInternalTypeID];
} else {
	if (specialBarlineDictionary[BarlineInternalTypeID] = '')
	{
	return '=??';
	} else {
	return specialBarlineDictionary[BarlineInternalTypeID];
	}
}}"
	CreateSpecialBarlineDictionary "() {
// note. Always add '=' + currentExternalBarNumber before the result of SpecialBarlineDictionary


specialBarlineDictionary = CreateDictionary(
'0','!|:',
'1',':|!',
'2',':',
'3','||',
'4','=',  // this will become '==' once you add the == before it
'5','-',
'6','??',  // Barline between staves. Not sure if standard in Humdrum
'7','',
'8','`',
'9','\''


);

return specialBarlineDictionary;}"
	CreateTokenIfBarStartsWithStartRepeat "(BarNumber) {
// Check if the bar at BarNumber starts with a Start Repeat Special Barline
// If it does, return  '!|:'
// If it doesn't, or if bar number it out of range, return ''

thisScore = Sibelius.ActiveScore;
sysStaff = thisScore.SystemStaff;
startsWithRepeat = false;

if (BarNumber > sysStaff.BarCount)
{
startsWithRepeat = false;  // this is redundant, but i'm keeping it for sake of clarity
} else {

sblCount = 1;
// this is not elegant, but basically see if there's a start repeat in bar 1

for each SpecialBarline sbl in sysStaff.NthBar(BarNumber)
	{
		if (sblCount = 1)
		{	
			if (sbl.BarlineInternalType = SpecialBarlineStartRepeat)
			{
			startsWithRepeat = true;
			}
		}
	}

}


if (startsWithRepeat = true)
{
return '!|:';
} else {
return '';
}}"
	CreateDurationDictionary "() {
durationDictionary = CreateDictionary(
'4096','00', //Long
'6144','00.', //DottedLong
'7168','00..', //DoubleDottedLong
'7680','00...', //TripleDottedLong
'2048','0', //Breve
'3072','0.', //DottedBreve
'3584','0..', //DoubleDottedBreve
'3840','0...', //TripleDottedBreve
'1024','1', //Whole
'1536','1.', //DottedWhole
'1792','1..', //DoubleDottedWhole
'1920','1...', //TripleDottedWhole
'512','2', //Half
'768','2.', //DottedHalf
'896','2..', //DoubleDottedHalf
'960','2...', //TripleDottedHalf
'256','4', //Quarter
'384','4.', //DottedQuarter
'448','4..', //DoubleDottedQuarter
'480','4...', //TripleDottedQuarter
'128','8', //Eighth
'192','8.', //DottedEighth
'224','8..', //DoubleDottedEight
'240','8...', //TripleDottedEight
'64','16', //Sixteenth
'96','16.', //DottedSixteenth
'112','16..', //DoubleDottedSixteeth
'120','16...', //TripleDottedSixteeth
'32','32', //ThirtySecond
'48','32.', //DottedThirtySecond
'56','32..', //DoubleDottedThirtySecond
'60','32...', //TripleDottedThirtySecond
'16','64', //SixtyFourth
'24','64.', //DottedSixtyFourth
'28','64..', //DoubleDottedSixtyFourth
'30','64...', //TripleDottedSixtyFourth
'8','128', //OneHundredTwentyEighth
'12','128.', //DottedOneHundredTwentyEighth
'14','128..', //DoubleDottedHundredTwentyEighth
'4','256', //TwoHundredFiftySixth
'6','256.' //DottedTwoHundredFiftySixth
);

return durationDictionary;}"
	ConvertDuration "(noteRest,durationDictionary) {
/* this is only for non tuplet conversion */

duration = noteRest.Duration;

if (noteRest.ParentTupletIfAny = null) // if not part of tuplet
{	
	if (durationDictionary[duration] = '')
	{
		return '??';
	} else {
		return durationDictionary[duration];
	}
} else {

		parentTuplet = noteRest.ParentTupletIfAny;
		divideByUnit = parentTuplet.PlayedDuration/parentTuplet.Unit;

		splitDurationAndDotsArray = SplitDurationAndDots(noteRest);
		duration = splitDurationAndDotsArray[0];
		dotToken = splitDurationAndDotsArray[1];

		tupletDrillDown = parentTuplet.PlayedDuration/duration/divideByUnit;
		parentTupletDividedByLeft = parentTuplet.PlayedDuration/parentTuplet.Left;

		if(IsTerminating(parentTuplet.Left,parentTuplet.Right)) // if possible to write tuplet without **recipe
		{
			humTupletNoteDuration = 256*4/parentTupletDividedByLeft*tupletDrillDown;
		} else {
		
			makeFractionArray = utils.MakeFraction(parentTupletDividedByLeft/tupletDrillDown,1024);
			humTupletNoteDuration = makeFractionArray[1] & '%' & makeFractionArray[0];
		}
humTupletNoteDuration = humTupletNoteDuration & dotToken;
return humTupletNoteDuration;

}
	
}"
	NoteRestAtBarPosVoice "(barCur, position, voice) {
/* This is almost exactly the same as utils.NoteRestWithNotesAtBarPosVoice, but it also returns NoteRest with NoteCount = 0, and ignores nr if GraceNote = true

All comments below are from utils.NoteRestWithNotesAtBarPosVoice */

// useful when adding notes to see if there is an nr with notes at the same location
// if so, the note will be added to that NR rather than starting a new one.
// this can let you decide to delete the nr
// returns the nr at that position if there is one, otherwise null

// ASSUMPTION: for each NoteRest nr in bar returns all notes in position order, so if we encounter an nr whose position is
// greater than the desired position we will not find a match, and it is safe to return null

for each NoteRest nr in barCur
{
	if (nr.NoteCount >= 0)
	{
		if (nr.VoiceNumber = voice)
		{
			if  (nr.Position = position)
			{
				if (nr.GraceNote = false)		// only return nr if NOT a grace note
				{
				return nr;	
				}
			}
		}
	}

	if (nr.Position > position)
	{
		return null;
	}
}

return null;}"
	ResetWholeBarRestTracker "() {
thisScore = Sibelius.ActiveScore;

wholeBarRestTrackerArray = CreateSparseArray();

x=1;
for each s in thisScore
{
wholeBarRestTrackerArray[x] = false;
x=x+1;
}

return wholeBarRestTrackerArray;}"
	CreatePitchDictionary "() {
pitchDictionary = CreateDictionary(

// Not sure how low / high Sib can go. Let's assume this is enough for now.

'1','DDDDD',
'2','EEEEE',
'3','FFFFF',
'4','GGGGG',
'5','AAAAA',
'6','BBBBB',
'7','CCCC', //C0
'8','DDDD',
'9','EEEE',
'10','FFFF',
'11','GGGG',
'12','AAAA',
'13','BBBB',
'14','CCC', //C1
'15','DDD',
'16','EEE',
'17','FFF',
'18','GGG',
'19','AAA',
'20','BBB',
'21','CC', //C2
'22','DD',
'23','EE',
'24','FF',
'25','GG',
'26','AA',
'27','BB',
'28','C', //C3
'29','D',
'30','E',
'31','F',
'32','G',
'33','A',
'34','B',
'35','c', //C4, middle C
'36','d',
'37','e',
'38','f',
'39','g',
'40','a',
'41','b',
'42','cc', //C5
'43','dd',
'44','ee',
'45','ff',
'46','gg',
'47','aa',
'48','bb',
'49','ccc', //C6
'50','ddd',
'51','eee',
'52','fff',
'53','ggg',
'54','aaa',
'55','bbb',
'56','cccc', //C7
'57','dddd',
'58','eeee',
'59','ffff',
'60','gggg',
'61','aaaa',
'62','bbbb',
'63','cccc', //C8
'64','dddd',
'65','eeee',
'66','ffff',
'67','gggg',
'68','aaaa',
'69','bbbb',
'70','ccccc', //C9
'71','ddddd',
'72','eeeee',
'73','fffff',
'74','ggggg',
'75','aaaaa',
'76','bbbbb',
'77','cccccc', //C10
'78','dddddd',
'79','eeeeee',
'80','ffffff',
'81','gggggg',
'82','aaaaaa',
'83','bbbbbb',
'84','ccccccc' //C11

);

return pitchDictionary;}"
	ConvertPitch "(note,pitchDictionary) {
/* Convert Sib DiatonicPitch to Humdrum format using the dictionary created with CreatePitchDictionary() ;  */

diatonicPitch = note.DiatonicPitch;
accidental = note.Accidental;
isAccidentalVisible = note.IsAccidentalVisible;

if (pitchDictionary[diatonicPitch] = '')
{
return '??';
} else {
humPitch = pitchDictionary[diatonicPitch];
}

humAccidental = '';
if (accidental = 0)
{
	if (isAccidentalVisible = true )
	{ 
	humAccidental = 'n' ; // only add natural if visible
	}
} else {
	if (accidental = -2)
	{
	humAccidental = '--';
	} else {
		if (accidental = -1)
		{
		humAccidental = '-';
		} else {
			if (accidental = 1)
			{
			humAccidental = '#';
			} else {
				if (accidental = 2)
				{
				humAccidental = '##';
				}
			}	
		}
	}
}
humToken = humPitch & humAccidental;
return humToken;}"
	CreateArticulationDictionary "() {
articulationDictionary = CreateDictionary(
'0','I', // Custom1Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I
'1','\'', // StaccatoArtic
'2','`', // StaccatissimoArtic
'3','`', // WedgeArtic. I believe there is no distinction between 2 and 3 in Humdrum.
'4','~', // TenutoArtic. 
'5','^', // AccentArtic
'6','^^',	// MarcatoArtic
'7','o', // HarmonicArtic  !!!RDF**kern: o = harmonic/open
'8','O',	// PlusArtic.  !!!RDF**kern: O = plus/closed 
'9','v', //UpBowArtic
'10','u', // DownBowArtic
'11','I', // Custom2Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I
'12',';', // SquarePauseArtic. I'm assigning every type of fermata to ;
'13',';', // PauseArtic. I'm assigning every type of fermata to ;
'14',';', // TriPauseArtic. I'm assigning every type of fermata to ;
'15','I' // Custom3Artic. I'm assigning this to generic articulation (unspecified articulation) in humdrum, which is I


);

return articulationDictionary;}"
	ConvertArticulation "(note,articulationDictionary) {
/*The + articulation is not readily acvailable in Humdrum. A general solution to unrepresented articulations is to use the !!!RDF**kern: system to assign a user signifier to mean something. Sib2hum uses

!!!RDF**kern: O = plus/closed

Note that this reference line is only added at the bottom of the output file if a plus articulation is used in the score.

As for the circle articulation, it can mean different things depending upon context. Because in humdum this signifier is usually only used for harmonic (and not, say, for unmuted brass instrument), I'm also adding this reference when a o articulation is used

!!!RDF**kern: o = harmonic/open

This last one is a bit weird, because theoretically, only user-defined signifiers can be described this way. But I think this still is a sensible solution.

*/


humArticulation = '' ;
closedArticulationReferenceNeeded = false ;
openArticulationReferenceNeeded = false ;


for x = 0 to 16 // possible articulations range from 0 to 15
{
	articulation = note.GetArticulation(x);
				if (articulation) // if articulation x exists on given note
				{
				humArticulation = humArticulation & articulationDictionary[x];
				}

	if (note.GetArticulation(7))
	{
	openArticulationReferenceNeeded = true;
	}

	if (note.GetArticulation(8))
	{	
	closedArticulationReferenceNeeded = true ;
	}

}			


articulationArray = CreateSparseArray(humArticulation,openArticulationReferenceNeeded,closedArticulationReferenceNeeded);

return articulationArray;
}"
	CreateSpinePathIndicators "(numberVoicesBefore,numberVoicesAfter) {
//Caution, the difference between numberVoicesAfter and numberVoicesBefore can only be 1 or -1



if (numberVoicesAfter - numberVoicesBefore = 1) // if we need to add a voice
{
	if(numberVoicesBefore = 1)
	{
	spinePathIndicators = '*^';
	}
	if(numberVoicesBefore = 2)
	{
	spinePathIndicators = '*\t*^';
	}
	if(numberVoicesBefore = 3)
	{
	spinePathIndicators = '*\t*\t*^';
	}
} else {
	if (numberVoicesAfter - numberVoicesBefore = -1)  // if we need to remove a voice
	{
		if(numberVoicesBefore = 4)
		{
		spinePathIndicators = '*\t*\t*v\t*v';
		}
		if(numberVoicesBefore = 3)
		{
		spinePathIndicators = '*\t*v\t*v';
		}
		if(numberVoicesBefore = 2)
		{
		spinePathIndicators = '*v\t*v';
		}
	}	
}

return spinePathIndicators;}"
	IsTerminating "(numerator, denominator) {
//assumes that the fraction is already fully reduced
//e.g. numerator and denominator are coprime

   while (denominator % 2 = 0)
        {
		denominator = denominator / 2;
		}
   while (denominator % 5 = 0)
		{
        denominator = denominator / 5;
		}
    if (denominator = 1)
	{ 
		return true;
	} else {
		return false;
	}}"
	ConvertTupletDuration "(IsTerminating) {
}"
	SplitDurationAndDots "(noteRest) {
duration = noteRest.Duration;
splitDurationAndDotsArray = CreateSparseArray();
		dotToken = '';
		switch(duration){
			case '6144' // DottedLong
			{
			duration = '4096';
			dotToken = '.';
			}
			case '7168' // DoubleDottedLong
			{
			duration = '4096';
			dotToken = '..';
			}
			case '7680' // TripleDottedLong
			{
			duration = '4096';
			dotToken = '...';
			}
			case '3072' // DottedBreve
			{
			duration = '2048';
			dotToken = '.';
			}
			case '3584' // DoubleDottedBreve
			{
			duration = '2048';
			dotToken = '..';
			}	
			case '3840' // TripleDottedBreve
			{
			duration = '2048';
			dotToken = '...';
			}	
			case '1536' // DottedWhole
			{
			duration = '1024';
			dotToken = '.';
			}
			case '1792' // DoubleDottedWhole
			{
			duration = '1024';
			dotToken = '..';
			}
			case '1920' // TripleDottedWhole
			{
			duration = '1024';
			dotToken = '...';
			}
			case '768' // DottedHalf
			{
			duration = '512';
			dotToken = '.';
			}
			case '896' // DoubleDottedHalf
			{
			duration = '512';
			dotToken = '..';
			}	
			case '960' // TripleDottedHalf
			{
			duration = '512';
			dotToken = '...';
			}
			case '384' // DottedQuarter
			{
			duration = '256';
			dotToken = '.';
			}	
			case '448' // DoubleDottedQuarter
			{
			duration = '256';
			dotToken = '..';
			}
			case '480' // TripleDottedQuarter
			{
			duration = '256';
			dotToken = '...';
			}
			case '192' // DottedEighth
			{
			duration = '128';
			dotToken = '.';
			}
			case '224' // DoubleDottedEight
			{
			duration = '128';
			dotToken = '..';
			}	
			case '240' // TripleDottedEight
			{
			duration = '128';
			dotToken = '...';
			}		
			case '96' // DottedSixteenth
			{
			duration = '64';
			dotToken = '.';
			}	
			case '112' // DoubleDottedSixteeth
			{
			duration = '64';
			dotToken = '..';
			}	
			case '120' // TripleDottedSixteeth
			{
			duration = '64';
			dotToken = '...';
			}	
			case '48' // DottedThirtySecond
			{
			duration = '32';
			dotToken = '.';
			}
			case '56' // DoubleDottedThirtySecond
			{
			duration = '32';
			dotToken = '..';
			}
			case '60' // TripleDottedThirtySecond
			{
			duration = '32';
			dotToken = '...';
			}
			case '24' // DottedSixtyFourth
			{
			duration = '16';
			dotToken = '.';
			}
			case '28' // DoubleDottedSixtyFourth
			{
			duration = '16';
			dotToken = '..';
			}	
			case '30' // TripleDottedSixtyFourth
			{
			duration = '16';
			dotToken = '...';
			}
			case '12' // DottedOneHundredTwentyEighth
			{
			duration = '8';
			dotToken = '.';
			}
			case '14' // DoubleDottedHundredTwentyEighth
			{
			duration = '8';
			dotToken = '..';
			}	
			case '6' // DottedTwoHundredFiftySixth
			{
			duration = '4';
			dotToken = '.';
			}			
		}

splitDurationAndDotsArray[0] = duration;
splitDurationAndDotsArray[1] = dotToken;

return splitDurationAndDotsArray;


}"
	BeginTie "(note,ongoingTiesArray,currentStaff,currentVoice,pitchDictionary) {
n = note;
v = currentVoice;


tieUniqueCode = currentStaff & '_' & v & '_' & ConvertPitch(n,pitchDictionary);






if (n.Tied = true)
{

	if (utils.IsInArray(ongoingTiesArray,tieUniqueCode) = True)
	{
	return '';
	} else { 
		return '[';
	}

} else {
return '';
}





}"
	AddToOngoiontTiesArray "(note,ongoingTiesArray,currentStaff,currentVoice,pitchDictionary) {
n = note;
v = currentVoice;

tieUniqueCode = '';

if (n.Tied = true)
{
tieUniqueCode = currentStaff & '_' & v & '_' & 	ConvertPitch(n,pitchDictionary);
	if (utils.IsInArray(ongoingTiesArray,tieUniqueCode) = false) //add if not already in array
	{	
	ongoingTiesArray[ongoingTiesArray.Length] = tieUniqueCode;
	}
							
							}			

return ongoingTiesArray;}"
	ContinueOrEndTie "(note,ongoingTiesArray,currentStaff,currentVoice,pitchDictionary) {
n = note;
v = currentVoice;
continueOrEndTieOutputArray = CreateSparseArray();	

tieUniqueCode = currentStaff & '_' & v & '_' & ConvertPitch(n,pitchDictionary);


removeTieUniqueCode = false;

if (utils.IsInArray(ongoingTiesArray,tieUniqueCode) = True) // if there is an ongoing tie for this note
{
	if (n.Tied = true) // if this note is tied to and from (i.e. middle of tie)
	{	
	humEndToken = '_';
	} else {
		humEndToken = ']';
		removeTieUniqueCode = true;
	}	

} else {
	humEndToken = '';
}

continueOrEndTieOutputArray[0] = humEndToken;
continueOrEndTieOutputArray[1] = tieUniqueCode;
continueOrEndTieOutputArray[2] = removeTieUniqueCode;

return continueOrEndTieOutputArray;}"
	RemoveFromSparseArray "(string,sparseArray) {

inputArray = sparseArray;
outputArray = CreateSparseArray();

elementIndex = 0;
for each e in sparseArray
{
	if (e != string)
	{
	outputArray[outputArray.Length] = e;
	}
elementIndex = elementIndex + 1;
}

return outputArray;}"
	TrimTabsLeading "(strOrig, fLeadingOnly) {
//This is exactly the same code as TrimBlanksLeading, but for \t (HLG)



// This removes all leading and (optionally) trailing \t from a string, and returns the stripped string
// Originally written by Bob Zawalich February 2011
strOrig = '' & strOrig; // force value in case a global variable was passed in
if (strOrig = '') // null stgring handled by assignment above
{
	return '';
}

strStrip = '';
lenOrig = Length(strOrig);
strStrip1 = '';

// get leading spaces
fContinue = True;
i = 0;
while (fContinue)
{
	c = Substring (strOrig,i,1);
	if (c != '\t')
	{
		fContinue = False;
	}
	else
	{
		i = i + 1;
	}
}

strStrip1 = Substring (strOrig, i);
if (fLeadingOnly)
{
	return strStrip1;
}

lenStrip1 = Length(strStrip1);
fContinue = True;
i = lenStrip1 - 1;
while (fContinue)
{
	if (i < 0)
	{
		fContinue = False;
	}
	else
	{
		c = Substring (strStrip1, i, 1);
		if (c != '\t')
		{
			fContinue = False;
		}	
		else
		{
			i = i - 1;
		}
	}
}

strStrip = Substring (strStrip1, 0, i + 1);

// trace('TrimBlanksLeading string, pre-stripped string, stripped string, original length, stripped length = ' & strOrig & ', *' & strStrip1 & '*, *' & strStrip & '*, ' & lenOrig & ', ' & Length(strStrip));
return strStrip;}"
	NoteRestGraceNoteAtBarPosVoice "(barCur, position, voice) {
/* This is almost exactly the same as NoteRestAtBarPosVoice, but with only to identify GraceNote

All comments below are from utils.NoteRestWithNotesAtBarPosVoice */

// useful when adding notes to see if there is an nr with notes at the same location
// if so, the note will be added to that NR rather than starting a new one.
// this can let you decide to delete the nr
// returns the nr at that position if there is one, otherwise null

// ASSUMPTION: for each NoteRest nr in bar returns all notes in position order, so if we encounter an nr whose position is
// greater than the desired position we will not find a match, and it is safe to return null

for each NoteRest nr in barCur
{
	if (nr.NoteCount >= 0)
	{
		if (nr.VoiceNumber = voice)
		{
			if  (nr.Position = position)
			{
				if (nr.GraceNote = true)		// only return nr if a grace note
				{
				return nr;	
				}
			}
		}
	}

	if (nr.Position > position)
	{
		return null;
	}
}

return null;}"
}