dottes: abc2xml/abc2xml.py comparison

comparison abc2xml/abc2xml.py @ 1084:b1dbb76f4eb9 build-default-404

Update abc2xml to latest - Python3 friendly.

author	Jim Hague <jim.hague@acm.org>
date	Fri, 18 Nov 2022 21:42:55 +0000
parents	4fab69a1027d
children

comparison

equal deleted inserted replaced

-:b66bc498220d
+:b1dbb76f4eb9
+#!/usr/bin/env python
 # coding=latin-1
 '''
-Copyright (C) 2012: Willem G. Vree
+Copyright (C) 2012-2018: Willem G. Vree
-Contributions: Nils Liberg, Nicolas Froment, Norman Schmidt, Reinier Maliepaard, Martin Tarenskeen
+Contributions: Nils Liberg, Nicolas Froment, Norman Schmidt, Reinier Maliepaard, Martin Tarenskeen,
+Paul Villiger, Alexander Scheutzow, Herbert Schneider, David Randolph, Michael Strasser
 This program is free software; you can redistribute it and/or modify it under the terms of the
-GNU General Public License as published by the Free Software Foundation; either version 2 of
+Lesser GNU General Public License as published by the Free Software Foundation;
-the License, or (at your option) any later version.
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See the GNU General Public License for more details. <http://www.gnu.org/licenses/gpl.html>.
+See the Lesser GNU General Public License for more details. <http://www.gnu.org/licenses/lgpl.html>.
 '''
+from functools import reduce
 from pyparsing import Word, OneOrMore, Optional, Literal, NotAny, MatchFirst
 from pyparsing import Group, oneOf, Suppress, ZeroOrMore, Combine, FollowedBy
 from pyparsing import srange, CharsNotIn, StringEnd, LineEnd, White, Regex
 from pyparsing import nums, alphas, alphanums, ParseException, Forward
 try:    import xml.etree.cElementTree as E
 except: import xml.etree.ElementTree as E
 import types, sys, os, re, datetime
-VERSION = 58
+VERSION = 238
+python3 = sys.version_info[0] > 2
+lmap = lambda f, xs: list (map (f, xs))   # eager map for python 3
+if python3:
+int_type = int
+list_type = list
+str_type = str
+uni_type = str
+stdin = sys.stdin.buffer   # read binary!
+else:
+int_type = types.IntType
+list_type = types.ListType
+str_type = types.StringTypes
+uni_type = types.UnicodeType
+stdin = sys.stdin
 def info (s, warn=1):
 x = (warn and '-- ' or '') + s
 try: sys.stderr.write (x + '\n')
 except: sys.stderr.write (repr (x) + '\n')
 def abc_grammar ():     # header, voice and lyrics grammar for ABC
-b1 = Word (u"-,'<>\u2019#", exact=1)  # catch misplaced chars in chords
 #-----------------------------------------------------------------
-# ABC header (fld_text elements are matched later with reg. epr's)
+# expressions that catch and skip some syntax errors (see corresponding parse expressions)
 #-----------------------------------------------------------------
+b1 = Word (u"-,'<>\u2019#", exact=1)    # catch misplaced chars in chords
+b2 = Regex ('[^H-Wh-w~=]*')             # same in user defined symbol definition
+b3 = Regex ('[^=]*')                    # same, second part
+#-----------------------------------------------------------------
+# ABC header (field_str elements are matched later with reg. epr's)
+#-----------------------------------------------------------------
 number = Word (nums).setParseAction (lambda t: int (t[0]))
-field_str = Regex (r'(?:\\.|[^]\\])*')  # match anything until end of field, skip escaped \]
+field_str = Regex (r'[^]]*')  # match anything until end of field
 field_str.setParseAction (lambda t: t[0].strip ())  # and strip spacing
 userdef_symbol  = Word (srange ('[H-Wh-w~]'), exact=1)
-fieldId = oneOf ('K L M Q P I T C O A Z N G H R B D F S E r') # info fields
+fieldId = oneOf ('K L M Q P I T C O A Z N G H R B D F S E r Y') # info fields
-X_field = Literal ('X') + Suppress (':') + number + field_str
+X_field = Literal ('X') + Suppress (':') + field_str
-U_field = Literal ('U') + Suppress (':') + userdef_symbol + Suppress ('=') + field_str
+U_field = Literal ('U') + Suppress (':') + b2 + Optional (userdef_symbol, 'H') + b3 + Suppress ('=') + field_str
 V_field = Literal ('V') + Suppress (':') + Word (alphanums + '_') + field_str
 inf_fld = fieldId + Suppress (':') + field_str
 ifield = Suppress ('[') + (X_field | U_field | V_field | inf_fld) + Suppress (']')
 abc_header = OneOrMore (ifield) + StringEnd ()
 simple_part = voiceId | voice_gr | Suppress ('|')
 grand_staff = oneOf ('{* {') + OneOrMore (simple_part) + Suppress ('}')
 part = Forward ()
 part_seq = OneOrMore (part | Suppress ('|'))
 brace_gr = Suppress ('{') + part_seq + Suppress ('}')
-bracket_gr = Suppress ('[') + part_seq + Suppress ('\]')    # closing brackets are escaped by splitHeaderVoices
+bracket_gr = Suppress ('[') + part_seq + Suppress (']')
-part << MatchFirst (simple_part | grand_staff | brace_gr | bracket_gr | Suppress ('|'))
+part <<= MatchFirst (simple_part | grand_staff | brace_gr | bracket_gr | Suppress ('|'))
 abc_scoredef = Suppress (oneOf ('staves score')) + OneOrMore (part)
+#----------------------------------------
+# ABC lyric lines (white space sensitive)
+#----------------------------------------
+skip_note   = oneOf ('* - ~')
+extend_note = Literal ('_')
+measure_end = Literal ('|')
+syl_str     = CharsNotIn ('*~-_| \t\n\\]')
+syl_chars   = Combine (OneOrMore (syl_str | Regex (r'\\.')))
+white       = Word (' \t')
+syllable    = Combine (Optional ('~') + syl_chars + ZeroOrMore (Literal ('~') + syl_chars)) + Optional ('-')
+lyr_elem    = (syllable | skip_note | extend_note | measure_end) + Optional (white).suppress ()
+lyr_line    = Optional (white).suppress () + ZeroOrMore (lyr_elem)
+syllable.setParseAction (lambda t: pObj ('syl', t))
+skip_note.setParseAction (lambda t: pObj ('skip', t))
+extend_note.setParseAction (lambda t: pObj ('ext', t))
+measure_end.setParseAction (lambda t: pObj ('sbar', t))
+lyr_line_wsp = lyr_line.leaveWhitespace ()   # parse actions must be set before calling leaveWhitespace
 #---------------------------------------------------------------------------------
 # ABC voice (not white space sensitive, beams detected in note/rest parse actions)
 #---------------------------------------------------------------------------------
 inline_field =  Suppress ('[') + (inf_fld | U_field | V_field) + Suppress (']')
+lyr_fld = Suppress ('[') + Suppress ('w') + Suppress (':') + lyr_line_wsp + Suppress (']')  # lyric line
+lyr_blk = OneOrMore (lyr_fld)       # verses
+fld_or_lyr = inline_field | lyr_blk # inline field or block of lyric verses
 note_length = Optional (number, 1) + Group (ZeroOrMore ('/')) + Optional (number, 2)
 octaveHigh = OneOrMore ("'").setParseAction (lambda t: len(t))
 octaveLow = OneOrMore (',').setParseAction (lambda t: -len(t))
 octave  = octaveHigh | octaveLow
 basenote = oneOf ('C D E F G A B c d e f g a b y')  # includes spacer for parse efficiency
 accidental = oneOf ('^^ __ ^ _ =')
 rest_sym  = oneOf ('x X z Z')
-slur_beg = oneOf ('( .(') + ~Word (nums)    # no tuplet_start
+slur_beg = oneOf ("( (, (' .( .(, .('") + ~Word (nums)    # no tuplet_start
 slur_ends = OneOrMore (oneOf (') .)'))
 long_decoration = Combine (oneOf ('! +') + CharsNotIn ('!+ \n') + oneOf ('! +'))
 staccato        = Literal ('.') + ~Literal ('|')    # avoid dotted barline
-decoration      = staccato | userdef_symbol | long_decoration | slur_beg
+pizzicato       = Literal ('!+!')   # special case: plus sign is old style deco marker
+decoration      = slur_beg | staccato | userdef_symbol | long_decoration | pizzicato
 decorations     = OneOrMore (decoration)
-staff_decos     = decorations + ~oneOf (': | [|] []')
 tie = oneOf ('.- -')
 rest = Optional (accidental) + rest_sym + note_length
 pitch = Optional (accidental) + basenote + Optional (octave, 0)
 note = pitch + note_length + Optional (tie) + Optional (slur_ends)
-chord_note = Optional (decorations) + pitch + note_length + Optional (tie) + Optional (slur_ends)
+dec_note = Optional (decorations) + pitch + note_length + Optional (tie) + Optional (slur_ends)
-chord_notes = OneOrMore (chord_note | rest | b1)
+chord_note = dec_note | rest | b1
 grace_notes = Forward ()
-chord = Suppress ('[') + OneOrMore (chord_notes | grace_notes) + Suppress (']') + note_length + Optional (tie) + Optional (slur_ends)
+chord = Suppress ('[') + OneOrMore (chord_note | grace_notes) + Suppress (']') + note_length + Optional (tie) + Optional (slur_ends)
 stem = note | chord | rest
 broken = Combine (OneOrMore ('<') | OneOrMore ('>'))
 tuplet_num   = Suppress ('(') + number
 tuplet_notes = Suppress (':') + Optional (number, 0)
 tuplet_start = tuplet_num + Optional (tuplet_into + Optional (tuplet_notes))
 acciaccatura    = Literal ('/')
 grace_stem      = Optional (decorations) + stem
-grace_notes     << Group (Suppress ('{') + Optional (acciaccatura) + OneOrMore (grace_stem) + Suppress ('}'))
+grace_notes     <<= Group (Suppress ('{') + Optional (acciaccatura) + OneOrMore (grace_stem) + Suppress ('}'))
 text_expression  = Optional (oneOf ('^ _ < > @'), '^') + Optional (CharsNotIn ('"'), "")
 chord_accidental = oneOf ('# b =')
 triad            = oneOf ('ma Maj maj M mi min m aug dim o + -')
-seventh          = oneOf ('7 ma7 Maj7 M7 maj7 mi7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5')
+seventh          = oneOf ('7 ma7 Maj7 M7 maj7 mi7 min7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5')
-sixth            = oneOf ('6 ma6 M6 m6 mi6')
+sixth            = oneOf ('6 ma6 M6 mi6 min6 m6')
-ninth            = oneOf ('9 ma9 M9 maj9 Maj9 mi9 m9')
+ninth            = oneOf ('9 ma9 M9 maj9 Maj9 mi9 min9 m9')
-elevn            = oneOf ('11 ma11 M11 maj11 Maj11 mi m11')
+elevn            = oneOf ('11 ma11 M11 maj11 Maj11 mi11 min11 m11')
+thirt            = oneOf ('13 ma13 M13 maj13 Maj13 mi13 min13 m13')
 suspended        = oneOf ('sus sus2 sus4')
 chord_degree     = Combine (Optional (chord_accidental) + oneOf ('2 4 5 6 7 9 11 13'))
-chord_kind       = Optional (seventh | sixth | ninth | elevn | triad, '_') + Optional (suspended)
+chord_kind       = Optional (seventh | sixth | ninth | elevn | thirt | triad) + Optional (suspended)
 chord_root       = oneOf ('C D E F G A B') + Optional (chord_accidental)
 chord_bass       = oneOf ('C D E F G A B') + Optional (chord_accidental) # needs a different parse action
 chordsym         = chord_root + chord_kind + ZeroOrMore (chord_degree) + Optional (Suppress ('/') + chord_bass)
 chord_sym        = chordsym + Optional (Literal ('(') + CharsNotIn (')') + Literal (')')).suppress ()
 chord_or_text    = Suppress ('"') + (chord_sym ^ text_expression) + Suppress ('"')
 double_rep = Literal (':') + FollowedBy (':')   # otherwise ambiguity with dashed barline
 voice_overlay = Combine (OneOrMore ('&'))
 bare_volta = FollowedBy (Literal ('[') + Word (nums))   # no barline, but volta follows (volta is parsed in next measure)
 bar_left = (oneOf ('[|: |: [: :') + Optional (volta)) | Optional ('|').suppress () + volta | oneOf ('| [|')
 bars = ZeroOrMore (':') + ZeroOrMore ('[') + OneOrMore (oneOf ('| ]'))
-bar_right = Optional (decorations) + (invisible_barline | double_rep | Combine (bars) | dashed_barline | voice_overlay | bare_volta)
+bar_right = invisible_barline | double_rep | Combine (bars) | dashed_barline | voice_overlay | bare_volta
 errors =  ~bar_right + Optional (Word (' \n')) + CharsNotIn (':&|', exact=1)
 linebreak = Literal ('$') | ~decorations + Literal ('!')    # no need for I:linebreak !!!
-element = inline_field | broken | staff_decos | stem | chord_or_text | grace_notes | tuplet_start | linebreak | errors
+element = fld_or_lyr | broken | decorations | stem | chord_or_text | grace_notes | tuplet_start | linebreak | errors
-measure      = Group (ZeroOrMore (inline_field) + Optional (bar_left) + ZeroOrMore (element) + bar_right + Optional (linebreak))
+measure      = Group (ZeroOrMore (inline_field) + Optional (bar_left) + ZeroOrMore (element) + bar_right + Optional (linebreak) + Optional (lyr_blk))
-noBarMeasure = Group (ZeroOrMore (inline_field) + Optional (bar_left) + OneOrMore (element) + Optional (linebreak))
+noBarMeasure = Group (ZeroOrMore (inline_field) + Optional (bar_left) + OneOrMore (element) + Optional (linebreak) + Optional (lyr_blk))
 abc_voice = ZeroOrMore (measure) + Optional (noBarMeasure | Group (bar_left)) + ZeroOrMore (inline_field).suppress () + StringEnd ()
 #----------------------------------------
-# ABC lyric lines (white space sensitive)
+# I:percmap note [step] [midi] [note-head]
 #----------------------------------------
-skip_note   = oneOf ('* - ~')
+white2 = (white | StringEnd ()).suppress ()
-extend_note = Literal ('_')
+w3 = Optional (white2)
-measure_end = Literal ('|')
+percid = Word (alphanums + '-')
-syl_chars   = CharsNotIn ('*~-_| \t\n')
+step = basenote + Optional (octave, 0)
-white       = Word (' \t')
+pitchg = Group (Optional (accidental, '') + step + FollowedBy (white2))
-syllable    = Combine (Optional ('~') + syl_chars + ZeroOrMore (Literal ('~') + syl_chars)) + Optional ('-')
+stepg = Group (step + FollowedBy (white2)) | Literal ('*')
-lyr_elem    = (syllable | skip_note | extend_note | measure_end) + Optional (white).suppress ()
+midi = (Literal ('*') | number | pitchg | percid)
-lyr_head    = (Literal ('w:') + Optional (white)).suppress ()
+nhd = Optional (Combine (percid + Optional ('+')), '')
-lyr_line    = Group (lyr_head + ZeroOrMore (lyr_elem) + LineEnd ().suppress ())
+perc_wsp = Literal ('percmap') + w3 + pitchg + w3 + Optional (stepg, '*') + w3 + Optional (midi, '*') + w3 + nhd
+abc_percmap = perc_wsp.leaveWhitespace ()
 #----------------------------------------------------------------
 # Parse actions to convert all relevant results into an abstract
 # syntax tree where all tree nodes are instances of pObj
 #----------------------------------------------------------------
 chord_kind.setParseAction (lambda t: pObj ('kind', t))
 chord_degree.setParseAction (lambda t: pObj ('degree', t))
 chord_bass.setParseAction (lambda t: pObj ('bass', t))
 text_expression.setParseAction (lambda t: pObj ('text', t))
 inline_field.setParseAction (lambda t: pObj ('inline', t))
-grace_notes.setParseAction (doGrace) # (lambda t: pObj ('grace', t))
+lyr_fld.setParseAction (lambda t: pObj ('lyr_fld', t, 1))
+lyr_blk.setParseAction (lambda t: pObj ('lyr_blk', t, 1)) # 1 = keep ordered list of lyric lines
+grace_notes.setParseAction (doGrace)
 acciaccatura.setParseAction (lambda t: pObj ('accia', t))
 note.setParseAction (noteActn)
-chord_note.setParseAction (noteActn)
 rest.setParseAction (restActn)
 decorations.setParseAction (lambda t: pObj ('deco', t))
+pizzicato.setParseAction (lambda t: ['!plus!']) # translate !+!
 slur_ends.setParseAction (lambda t: pObj ('slurs', t))
-chord.setParseAction (lambda t: pObj ('chord', t))
+chord.setParseAction (lambda t: pObj ('chord', t, 1))
+dec_note.setParseAction (noteActn)
 tie.setParseAction (lambda t: pObj ('tie', t))
 pitch.setParseAction (lambda t: pObj ('pitch', t))
 bare_volta.setParseAction (lambda t: ['|']) # return barline that user forgot
 dashed_barline.setParseAction (lambda t: ['.|'])
 bar_right.setParseAction (lambda t: pObj ('rbar', t))
 broken.setParseAction (lambda t: pObj ('broken', t))
 tuplet_start.setParseAction (lambda t: pObj ('tup', t))
 linebreak.setParseAction (lambda t: pObj ('linebrk', t))
 measure.setParseAction (doMaat)
 noBarMeasure.setParseAction (doMaat)
-syllable.setParseAction (lambda t: pObj ('syl', t))
-skip_note.setParseAction (lambda t: pObj ('skip', t))
-extend_note.setParseAction (lambda t: pObj ('ext', t))
-measure_end.setParseAction (lambda t: pObj ('sbar', t))
 b1.setParseAction (errorWarn)
+b2.setParseAction (errorWarn)
+b3.setParseAction (errorWarn)
 errors.setParseAction (errorWarn)
-lyr_block   = OneOrMore (lyr_line).leaveWhitespace ()   # after leaveWhiteSpace no more parse actions can be set!!
+return abc_header, abc_voice, abc_scoredef, abc_percmap
-return abc_header, abc_voice, lyr_block, abc_scoredef
 class pObj (object):    # every relevant parse result is converted into a pObj
 def __init__ (s, name, t, seq=0):   # t = list of nested parse results
 s.name = name   # name uniqueliy identifies this pObj
 rest = []       # collect parse results that are not a pObj
 if nm.startswith ('_'): continue # skip build in attributes
 elif nm == 'name': continue     # redundant
 else:
 x = getattr (s, nm)
 if not x: continue          # s.t may be empty (list of non-pObj's)
-if type (x) == types.ListType:  r.extend (x)
+if type (x) == list_type:  r.extend (x)
 else:                           r.append (x)
 xs = []
 for x in r:     # recursively call __repr__ and convert all strings to latin-1
-if isinstance (x, types.StringTypes):
+if isinstance (x, str_type): xs.append (x)          # string -> no recursion
-try:    xs.append (x.encode ('latin-1'))
+else:                        xs.append (repr (x))   # pObj -> recursive call
-except: xs.append (repr (x))    # string -> no recursion
-else:       xs.append (repr (x))    # pObj -> recursive call
 return '(' + s.name + ' ' +','.join (xs) + ')'
 global prevloc                  # global to remember previous match position of a note/rest
 prevloc = 0
 def detectBeamBreak (line, loc, t):
 def restActn (line, loc, t):    # detect beambreak between previous and current note/rest
 detectBeamBreak (line, loc, t)  # adds beambreak to parse result t as side effect
 return pObj ('rest', t)
-def errorWarn (line, loc, t):      # warning for misplaced symbols and skip them
+def errorWarn (line, loc, t):   # warning for misplaced symbols and skip them
+if not t[0]: return []      # only warn if catched string not empty
 info ('**misplaced symbol: %s' % t[0], warn=0)
 lineCopy = line [:]
 if loc > 40:
 lineCopy = line [loc - 40: loc + 40]
 loc = 40
 #-------------------------------------------------------------
 def simplify (a, b):    # divide a and b by their greatest common divisor
 x, y = a, b
 while b: a, b = b, a % b
-return x / a, y / a
+return x // a, y // a
 def doBroken (prev, brk, x):
 if not prev: info ('error in broken rhythm: %s' % x); return    # no changes
 nom1, den1 = prev.dur.t # duration of first note/chord
 nom2, den2 = x.dur.t    # duration of second note/chord
 elif x.name == 'broken':
 brk = x.t[0]            # remember the broken symbol (=string)
 remove.insert (0, i)    # and its index, highest index first
 for i in remove: del t[i]       # delete broken symbols from high to low
+def ptc2midi (n):       # convert parsed pitch attribute to a midi number
+pt = getattr (n, 'pitch', '')
+if pt:
+p = pt.t
+if len (p) == 3: acc, step, oct = p
+else:       acc = ''; step, oct = p
+nUp = step.upper ()
+oct = (4 if nUp == step else 5) + int (oct)
+midi = oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (nUp)] + {'^':1,'_':-1}.get (acc, 0) + 12
+else: midi = 130    # all non pitch objects first
+return midi
 def convertChord (t):   # convert chord to sequence of notes in musicXml-style
 ins = []
 for i, x in enumerate (t):
 if x.name == 'chord':
 if hasattr (x, 'rest') and not hasattr (x, 'note'): # chords containing only rests
-if type (x.rest) == types.ListType: x.rest = x.rest[0]  # more rests == one rest
+if type (x.rest) == list_type: x.rest = x.rest[0] # more rests == one rest
 ins.insert (0, (i, [x.rest]))   # just output a single rest, no chord
 continue
 num1, den1 = x.dur.t                # chord duration
 tie = getattr (x, 'tie', None)      # chord tie
 slurs = getattr (x, 'slurs', [])    # slur endings
-deco = getattr (x, 'deco', [])      # chord decorations
+if type (x.note) != list_type: x.note = [x.note]    # when chord has only one note ...
-if type (x.note) != types.ListType: x.note = [x.note]   # when chord has only one note ...
+elms = []; j = 0                    # sort chord notes, highest first
-for j, nt in enumerate (x.note):    # all notes of the chord
+nss = sorted (x.objs, key = ptc2midi, reverse=1) if mxm.orderChords else x.objs
-num2, den2 = nt.dur.t           # note duration * chord duration
+for nt in nss:   # all chord elements (note | decorations | rest | grace note)
-nt.dur.t = simplify (num1 * num2, den1 * den2)
+if nt.name == 'note':
-if tie: nt.tie = tie            # tie on all chord notes
+num2, den2 = nt.dur.t           # note duration * chord duration
-if j == 0 and deco: nt.deco = deco      # decorations only on first chord note
+nt.dur.t = simplify (num1 * num2, den1 * den2)
-if j == 0 and slurs: nt.slurs = slurs   # slur endings only on first chord note
+if tie: nt.tie = tie            # tie on all chord notes
-if j > 0: nt.chord = pObj ('chord', [1]) # label all but first as chord notes
+if j == 0 and slurs: nt.slurs = slurs   # slur endings only on first chord note
-else:                           # remember all pitches of the chord in the first note
+if j > 0: nt.chord = pObj ('chord', [1]) # label all but first as chord notes
-pitches = [n.pitch for n in x.note] # to implement conversion of erroneous ties to slurs
+else:                           # remember all pitches of the chord in the first note
-nt.pitches = pObj ('pitches', pitches)
+pitches = [n.pitch for n in x.note] # to implement conversion of erroneous ties to slurs
-ins.insert (0, (i, x.note))         # high index first
+nt.pitches = pObj ('pitches', pitches)
+j += 1
+if nt.name not in ['dur','tie','slurs','rest']: elms.append (nt)
+ins.insert (0, (i, elms))           # chord position, [note|decotation|grace note]
 for i, notes in ins:                        # insert from high to low
 for nt in reversed (notes):
 t.insert (i+1, nt)                  # insert chord notes after chord
 del t[i]                                # remove chord itself
 #--------------------
 # musicXML generation
 #----------------------------------
 def compChordTab ():    # avoid some typing work: returns mapping constant {ABC chordsyms -> musicXML kind}
-maj, min, aug, dim, dom, ch7, ch6, ch9, ch11, hd = 'major minor augmented diminished dominant -seventh -sixth -ninth -11th half-diminished'.split ()
+maj, min, aug, dim, dom, ch7, ch6, ch9, ch11, ch13, hd = 'major minor augmented diminished dominant -seventh -sixth -ninth -11th -13th half-diminished'.split ()
 triad   = zip ('ma Maj maj M mi min m aug dim o + -'.split (), [maj, maj, maj, maj, min, min, min, aug, dim, dim, aug, min])
-seventh = zip ('7 ma7 Maj7 M7 maj7 mi7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5'.split (),
+seventh = zip ('7 ma7 Maj7 M7 maj7 mi7 min7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5'.split (),
-[dom, maj+ch7, maj+ch7, maj+ch7, maj+ch7, min+ch7, min+ch7, dim+ch7, dim+ch7, min+ch7, aug+ch7, aug+ch7, hd, hd])
+[dom, maj+ch7, maj+ch7, maj+ch7, maj+ch7, min+ch7, min+ch7, min+ch7, dim+ch7, dim+ch7, min+ch7, aug+ch7, aug+ch7, hd, hd])
-sixth   = zip ('6 ma6 M6 mi6 m6'.split (), [maj+ch6, maj+ch6, maj+ch6, min+ch6, min+ch6])
+sixth   = zip ('6 ma6 M6 mi6 min6 m6'.split (), [maj+ch6, maj+ch6, maj+ch6, min+ch6, min+ch6, min+ch6])
-ninth   = zip ('9 ma9 M9 maj9 Maj9 mi9 m9'.split (), [dom+ch9, maj+ch9, maj+ch9, maj+ch9, maj+ch9, min+ch9, min+ch9])
+ninth   = zip ('9 ma9 M9 maj9 Maj9 mi9 min9 m9'.split (), [dom+ch9, maj+ch9, maj+ch9, maj+ch9, maj+ch9, min+ch9, min+ch9, min+ch9])
-elevn   = zip ('11 ma11 M11 maj11 Maj11 mi11 m11'.split (), [dom+ch11, maj+ch11, maj+ch11, maj+ch11, maj+ch11, min+ch11, min+ch11])
+elevn   = zip ('11 ma11 M11 maj11 Maj11 mi11 min11 m11'.split (), [dom+ch11, maj+ch11, maj+ch11, maj+ch11, maj+ch11, min+ch11, min+ch11, min+ch11])
-return dict (triad + seventh + sixth + ninth + elevn)
+thirt   = zip ('13 ma13 M13 maj13 Maj13 mi13 min13 m13'.split (), [dom+ch13, maj+ch13, maj+ch13, maj+ch13, maj+ch13, min+ch13, min+ch13, min+ch13])
+sus     = zip ('sus sus4 sus2'.split (), ['suspended-fourth', 'suspended-fourth', 'suspended-second'])
+return dict (list (triad) + list (seventh) + list (sixth) + list (ninth) + list (elevn) + list (thirt) + list (sus))
 def addElem (parent, child, level):
 indent = 2
-chldrn = parent.getchildren ()
+chldrn = list (parent)
 if chldrn:
 chldrn[-1].tail += indent * ' '
 else:
 parent.text = '\n' + level * indent * ' '
 parent.append (child)
 def addElemT (parent, tag, text, level):
 e = E.Element (tag)
 e.text = text
 addElem (parent, e, level)
+return e
 def mkTmod (tmnum, tmden, lev):
 tmod = E.Element ('time-modification')
 addElemT (tmod, 'actual-notes', str (tmnum), lev + 1)
 addElemT (tmod, 'normal-notes', str (tmden), lev + 1)
 return tmod
-def addDirection (parent, elem, lev, gstaff, subelms=[], placement='below', cue_on=0):
+def addDirection (parent, elems, lev, gstaff, subelms=[], placement='below', cue_on=0):
 dir = E.Element ('direction', placement=placement)
 addElem (parent, dir, lev)
-typ = E.Element ('direction-type')
+if type (elems) != list_type: elems = [(elems, subelms)]    # ugly hack to provide for multiple direction types
-addElem (dir, typ, lev + 1)
+for elem, subelms in elems: # add direction types
-addElem (typ, elem, lev + 2)
+typ = E.Element ('direction-type')
-for subel in subelms: addElem (elem, subel, lev + 3)
+addElem (dir, typ, lev + 1)
+addElem (typ, elem, lev + 2)
+for subel in subelms: addElem (elem, subel, lev + 3)
 if cue_on: addElem (dir, E.Element ('level', size='cue'), lev + 1)
 if gstaff: addElemT (dir, 'staff', str (gstaff), lev + 1)
 return dir
 def removeElems (root_elem, parent_str, elem_str):
 def alignLyr (vce, lyrs):
 empty_el = pObj ('leeg', '*')
 for k, lyr in enumerate (lyrs): # lyr = one full line of lyrics
 i = 0               # syl counter
-for msre in vce:    # reiterate the voice block for each lyrics line
+for elem in vce:    # reiterate the voice block for each lyrics line
-for elem in msre:
+if elem.name == 'note' and not (hasattr (elem, 'chord') or hasattr (elem, 'grace')):
-if elem.name == 'note' and not (hasattr (elem, 'chord') or hasattr (elem, 'grace')):
+if i >= len (lyr): lr = empty_el
-if i >= len (lyr): lr = empty_el
+else: lr = lyr [i]
-else: lr = lyr [i]
+lr.t[0] = lr.t[0].replace ('%5d',']')
 elem.objs.append (lr)
 if lr.name != 'sbar': i += 1
-if i < len (lyr) and lyr[i].name == 'sbar': i += 1
+if elem.name == 'rbar' and i < len (lyr) and lyr[i].name == 'sbar': i += 1
 return vce
 slur_move = re.compile (r'(?<![!+])([}><][<>]?)(\)+)')  # (?<!...) means: not preceeded by ...
 mm_rest = re.compile (r'([XZ])(\d+)')
 bar_space = re.compile (r'([:|][ |\[\]]+[:|])')         # barlines with spaces
 x = mm_rest.sub (f, x)
 x = bar_space.sub (g, x)
 return slur_move.sub (r'\2\1', x)
 def splitHeaderVoices (abctext):
+escField = lambda x: '[' + x.replace (']',r'%5d') + ']' # hope nobody uses %5d in a field
 r1 = re.compile (r'%.*$')           # comments
-r2 = re.compile (r'^[A-Z]:.*$')     # information field
+r2 = re.compile (r'^([A-Zw]:.*$)|\[[A-Zw]:[^]]*]$')     # information field, including lyrics
 r3 = re.compile (r'^%%(?=[^%])')    # directive: ^%% folowed by not a %
-xs, nx = [], 0
+xs, nx, mcont, fcont = [], 0, 0, 0  # result lines, X-encountered, music continuation, field continuation
+mln = fln = ''                      # music line, field line
 for x in abctext.splitlines ():
 x = x.strip ()
-if not x and nx == 1: break     # end of tune
+if not x and nx == 1: break     # end of tune (empty line)
+if x.startswith ('X:'):
+if nx == 1: break           # second tune starts without an empty line !!
+nx = 1                      # start first tune
 x = r3.sub ('I:', x)            # replace %% -> I:
 x2 = r1.sub ('', x)             # remove comment
-while x2.endswith ('*'): x2 = x2[:-1]   # remove old syntax for right adjusting
+while x2.endswith ('*') and not (x2.startswith ('w:') or x2.startswith ('+:') or 'percmap' in x2):
+x2 = x2[:-1]                # remove old syntax for right adjusting
 if not x2: continue             # empty line
-if x2[:2] == 'W:': continue     # skip W: lyrics
+if x2[:2] == 'W:':
-if x2[:2] == 'w:' and xs[-1][-1] ==  '\\':
+field = x2 [2:].strip ()
-xs[-1] = xs[-1][:-1]        # ignore line continuation before lyrics line
+ftype = mxm.metaMap.get ('W', 'W')  # respect the (user defined --meta) mapping of various ABC fields to XML meta data types
-ro = r2.match (x2)
+c = mxm.metadata.get (ftype, '')
+mxm.metadata [ftype] = c + '\n' + field if c else field   # concatenate multiple info fields with new line as separator
+continue                    # skip W: lyrics
+if x2[:2] == '+:':              # field continuation
+fln += x2[2:]
+continue
+ro = r2.match (x2)              # single field on a line
 if ro:                          # field -> inline_field, escape all ']'
-if x2[-1] == '\\': x2 = x2[:-1] # ignore continuation after field line
+if fcont:                   # old style \-info-continuation active
-x2 = '[' + x2.replace (']',r'\]') + ']'
+fcont = x2 [-1] == '\\' # possible further \-info-continuation
-if x2[:2] == '+:':              # new style continuation
+fln += re.sub (r'^.:(.*?)\\*$', r'\1', x2) # add continuation, remove .: and \
-xs[-1] += x2[2:]
+continue
-elif xs and xs[-1][-1] ==  '\\':  # old style continuation
+if fln: mln += escField (fln)
-xs[-1] = xs[-1][:-1] + x2
+if x2.startswith ('['): x2 = x2.strip ('[]')
-else:                           # skip lines (except I:) until first X:
+fcont = x2 [-1] == '\\'     # first encounter of old style \-info-continuation
-if x.startswith ('X:'):
+fln = x2.rstrip ('\\')      # remove continuation from field and inline brackets
-if nx == 1: break       # second tune starts without an empty line !!
+continue
-nx = 1                  # start of first tune
+if nx == 1:                     # x2 is a new music line
-if nx == 1 or x.startswith ('I:'):
+fcont = 0                   # stop \-continuations (-> only adjacent \-info-continuations are joined)
-xs.append (x2)
+if fln:
-if xs and xs[-1][-1] == '\\':       # nothing left to continue with, remove last continuation
+mln +=  escField (fln)
-xs[-1] = xs[-1][:-1]
+fln = ''
+if mcont:
-r1 = re.compile (r'\[[A-Z]:(\\.|[^]\\])*\]') # inline field with escaped ']'
+mcont = x2 [-1] == '\\'
-r2 = re.compile (r'\[K:')           # start of K: field
+mln += x2.rstrip ('\\')
-r3 = re.compile (r'\[V:|\[I:MIDI')  # start of V: field or midi field
+else:
-fields, voices, b = [], [], 0
+if mln: xs.append (mln); mln = ''
-for i, x in enumerate (xs):
+mcont = x2 [-1] == '\\'
-n = len (r1.sub ('', x))        # remove all inline fields
+mln = x2.rstrip ('\\')
-if n > 0: b = 1; break          # real abc present -> end of header
+if not mcont: xs.append (mln); mln = ''
-if r2.search (x):               # start of K: field
+if fln: mln += escField (fln)
-fields.append (x)
+if mln: xs.append (mln)
-i += 1; b = 1
-break                       # first K: field -> end of header
+hs = re.split (r'(\[K:[^]]*\])', xs [0])   # look for end of header K:
-if r3.search (x):               # start of V: field
+if len (hs) == 1: header = hs[0]; xs [0] = ''               # no K: present
-voices.append (x)
+else: header = hs [0] + hs [1]; xs [0] = ''.join (hs[2:])   # h[1] is the first K:
-else:
+abctext = '\n'.join (xs)                    # the rest is body text
-fields.append (x)
+hfs, vfs = [], []
-if b: voices += xs[i:]
+for x in header[1:-1].split (']['):
-else: voices += []                  # tune has only header fields
+if x[0] == 'V': vfs.append (x)          # filter voice- and midi-definitions
-header =  '\n'.join (fields)
+elif x[:6] == 'I:MIDI': vfs.append (x)  # from the header to vfs
-abctext = '\n'.join (voices)
+elif x[:9] == 'I:percmap': vfs.append (x)  # and also percmap
+else: hfs.append (x)                    # all other fields stay in header
+header = '[' + ']['.join (hfs) + ']'        # restore the header
+abctext = ('[' + ']['.join (vfs) + ']' if vfs else '') + abctext    # prepend voice/midi from header before abctext
 xs = abctext.split ('[V:')
 if len (xs) == 1: abctext = '[V:1]' + abctext # abc has no voice defs at all
-elif r1.sub ('', xs[0]).strip ():   # remove inline fields from starting text, if any
+elif re.sub (r'\[[A-Z]:[^]]*\]', '', xs[0]).strip ():   # remove inline fields from starting text, if any
 abctext = '[V:1]' + abctext     # abc with voices has no V: at start
 r1 = re.compile (r'\[V:\s*(\S*)[ \]]') # get voice id from V: field (skip spaces betwee V: and ID)
 vmap = {}                           # {voice id -> [voice abc string]}
 vorder = {}                         # mark document order of voices
 xs = re.split (r'(\[V:[^]]*\])', abctext)   # split on every V-field (V-fields included in split result list)
-if len (xs) == 1: raise (Exception ('bugs ...'))
+if len (xs) == 1: raise ValueError ('bugs ...')
 else:
-header += xs[0]     # xs[0] = text between K: and first V:, normally empty, but we put it in the header
+pm = re.findall (r'\[P:.\]', xs[0])         # all P:-marks after K: but before first V:
+if pm: xs[2] = ''.join (pm) + xs[2]         # prepend P:-marks to the text of the first voice
+header += re.sub (r'\[P:.\]', '', xs[0])    # clear all P:-marks from text between K: and first V: and put text in the header
 i = 1
 while i < len (xs):             # xs = ['', V-field, voice abc, V-field, voice abc, ...]
 vce, abc = xs[i:i+2]
 id = r1.search (vce).group (1)                  # get voice ID from V-field
+if not id: id, vce = '1', '[V:1]'               # voice def has no ID
 vmap[id] = vmap.get (id, []) + [vce, abc]       # collect abc-text for each voice id (include V-fields)
 if id not in vorder: vorder [id] = i            # store document order of first occurrence of voice id
 i += 2
 voices = []
 ixs = sorted ([(i, id) for id, i in vorder.items ()])   # restore document order of voices
 for i, id in ixs:
-voice = ''.join (vmap [id])                         # all abc of one voice
+voice = ''.join (vmap [id])     # all abc of one voice
-xs = re.split (r'((?:\nw:[^\n]*)+)', voice)         # split voice into voice-lyrics blocks
+voice = fixSlurs (voice)        # put slurs right after the notes
-if len (xs) == 1:               # no lyrics
+voices.append ((id, voice))
-voice = fixSlurs (xs[0])    # put slurs right after the notes
-vce_lyr = [[voice, '']]
-else:
-if xs[-1].strip () != '': xs.append ('w:')               # last block had no lyrics
-vce_lyr = []                # [[voice, lyrics],[],...] list of voice-lyrics blocks
-for k in range (0, len (xs) - 1, 2):
-voice, lyrics = xs [k:k+2]
-voice = fixSlurs (voice)    # put slurs right after the notes
-vce_lyr.append ((voice, lyrics))
-voices.append ((id, vce_lyr))
 return header, voices
-def mergeMeasure (m1, m2, slur_offset, voice_offset, is_grand=0):
+def mergeMeasure (m1, m2, slur_offset, voice_offset, rOpt, is_grand=0, is_overlay=0):
 slurs = m2.findall ('note/notations/slur')
 for slr in slurs:
 slrnum = int (slr.get ('number')) + slur_offset
 slr.set ('number', str (slrnum))    # make unique slurnums in m2
 vs = m2.findall ('note/voice')          # set all voice number elements in m2
 el.set ('number', str (n + lnum_max))
 ns = m1.findall ('note')    # determine the total duration of m1, subtract all backups
 dur1 = sum (int (n.find ('duration').text) for n in ns
 if n.find ('grace') == None and n.find ('chord') == None)
 dur1 -= sum (int (b.text) for b in m1.findall ('backup/duration'))
-nns, es = 0, []             # nns = number of real notes in m2
+repbar, nns, es = 0, 0, []  # nns = number of real notes in m2
-for e in m2.getchildren (): # scan all elements of m2
+for e in list (m2): # scan all elements of m2
 if e.tag == 'attributes':
 if not is_grand: continue # no attribute merging for normal voices
-else: nns += 1       # but we do merge (clef) attributes for a grand staff
+else: nns += 1      # but we do merge (clef) attributes for a grand staff
 if e.tag == 'print': continue
-if e.tag == 'note' and (mxm.gmwr or e.find ('rest') == None): nns += 1
+if e.tag == 'note' and (rOpt or e.find ('rest') == None): nns += 1
+if e.tag == 'barline' and e.find ('repeat') != None: repbar = e;
 es.append (e)           # buffer elements to be merged
 if nns > 0:                 # only merge if m2 contains any real notes
 if dur1 > 0:            # only insert backup if duration of m1 > 0
 b = E.Element ('backup')
 addElem (m1, b, level=3)
 addElemT (b, 'duration', str (dur1), level=4)
 for e in es: addElem (m1, e, level=3)   # merge buffered elements of m2
+elif is_overlay and repbar: addElem (m1, repbar, level=3)   # merge repeat in empty overlay
-def mergePartList (parts, is_grand=0):  # merge parts, make grand staff when is_grand true
+def mergePartList (parts, rOpt, is_grand=0):    # merge parts, make grand staff when is_grand true
 def delAttrs (part):                # for the time being we only keep clef attributes
 xs = [(m, e) for m in part.findall ('measure') for e in m.findall ('attributes')]
 for m, e in xs:
-for c in e.getchildren ():
+for c in list (e):
 if c.tag == 'clef': continue    # keep clef attribute
+if c.tag == 'staff-details': continue    # keep staff-details attribute
 e.remove (c)                    # delete all other attrinutes for higher staff numbers
-if len (e.getchildren ()) == 0: m.remove (e)    # remove empty attributes element
+if len (list (e)) == 0: m.remove (e)    # remove empty attributes element
 p1 = parts[0]
 for p2 in parts[1:]:
 if is_grand: delAttrs (p2)                          # delete all attributes except clef
 for i in range (len (p1) + 1, len (p2) + 1):        # second part longer than first one
 slurs = p1.findall ('measure/note/notations/slur')  # find highest slur num in first part
 slur_max = max ([int (slr.get ('number')) for slr in slurs] + [0])
 vs = p1.findall ('measure/note/voice')              # all voice number elements in first part
 vnum_max = max ([int (v.text) for v in vs] + [0])   # highest voice number in first part
 for im, m2 in enumerate (p2.findall ('measure')):   # merge all measures of p2 into p1
-mergeMeasure (p1[im], m2, slur_max, vnum_max, is_grand) # may change slur numbers in p1
+mergeMeasure (p1[im], m2, slur_max, vnum_max, rOpt, is_grand) # may change slur numbers in p1
 return p1
-def mergeParts (parts, vids, staves, is_grand=0):
+def mergeParts (parts, vids, staves, rOpt, is_grand=0):
 if not staves: return parts, vids   # no voice mapping
 partsnew, vidsnew = [], []
 for voice_ids in staves:
 pixs = []
 for vid in voice_ids:
 if vid in vids: pixs.append (vids.index (vid))
 else: info ('score partname %s does not exist' % vid)
 if pixs:
 xparts = [parts[pix] for pix in pixs]
-if len (xparts) > 1: mergedpart = mergePartList (xparts, is_grand)
+if len (xparts) > 1: mergedpart = mergePartList (xparts, rOpt, is_grand)
 else:                mergedpart = xparts [0]
 partsnew.append (mergedpart)
 vidsnew.append (vids [pixs[0]])
 return partsnew, vidsnew
-def mergePartMeasure (part, msre, ovrlaynum):               # merge msre into last measure of part, only for overlays
+def mergePartMeasure (part, msre, ovrlaynum, rOpt): # merge msre into last measure of part, only for overlays
-slurs = part.findall ('measure/note/notations/slur')    # find highest slur num in part
+slur_offset = 0;    # slur numbers determined by the slurstack size (as in a single voice)
-slur_max = max ([int (slr.get ('number')) for slr in slurs] + [0])
+last_msre = list (part)[-1] # last measure in part
-last_msre = part.getchildren ()[-1] # last measure in part
+mergeMeasure (last_msre, msre, slur_offset, ovrlaynum, rOpt, is_overlay=1) # voice offset = s.overlayVNum
-mergeMeasure (last_msre, msre, slur_max, ovrlaynum)     # voice offset = s.overlayVNum
+def pushSlur (boogStapel, stem):
+if stem not in boogStapel: boogStapel [stem] = [] # initialize slurstack for stem
+boognum = sum (map (len, boogStapel.values ())) + 1  # number of open slurs in all (overlay) voices
+boogStapel [stem].append (boognum)
+return boognum
 def setFristVoiceNameFromGroup (vids, vdefs): # vids = [vid], vdef = {vid -> (name, subname, voicedef)}
 vids = [v for v in vids if v in vdefs]  # only consider defined voices
 if not vids: return vdefs
 vid0 = vids [0]                         # first vid of the group
 else: xs.extend (mkGroups (x) + ['}'])  # x.name == 'grand' == rejected grand staff
 else:
 xs.append (p.t[0])
 return xs
+def stepTrans (step, soct, clef):   # [A-G] (1...8)
+if clef.startswith ('bass'):
+nm7 = 'C,D,E,F,G,A,B'.split (',')
+n = 14 + nm7.index (step) - 12  # two octaves extra to avoid negative numbers
+step, soct = nm7 [n % 7], soct + n // 7 - 2  # subtract two octaves again
+return step, soct
+def reduceMids (parts, vidsnew, midiInst):       # remove redundant instruments from a part
+for pid, part in zip (vidsnew, parts):
+mids, repls, has_perc = {}, {}, 0
+for ipid, ivid, ch, prg, vol, pan in sorted (list (midiInst.values ())):
+if ipid != pid: continue                # only instruments from part pid
+if ch == '10': has_perc = 1; continue   # only consider non percussion instruments
+instId, inst = 'I%s-%s' % (ipid, ivid), (ch, prg)
+if inst in mids:                        # midi instrument already defined in this part
+repls [instId]  = mids [inst]       # remember to replace instId by inst (see below)
+del midiInst [instId]               # instId is redundant
+else: mids [inst] = instId              # collect unique instruments in this part
+if len (mids) < 2 and not has_perc:         # only one instrument used -> no instrument tags needed in notes
+removeElems (part, 'measure/note', 'instrument')    # no instrument tag needed for one- or no-instrument parts
+else:
+for e in part.findall ('measure/note/instrument'):
+id = e.get ('id')                   # replace all redundant instrument Id's
+if id in repls: e.set ('id', repls [id])
+class stringAlloc:
+def __init__ (s):
+s.snaarVrij = []    # [[(t1, t2) ...] for each string ]
+s.snaarIx = []      # index in snaarVrij for each string
+s.curstaff = -1     # staff being allocated
+def beginZoek (s):      # reset snaarIx at start of each voice
+s.snaarIx = []
+for i in range (len (s.snaarVrij)): s.snaarIx.append (0)
+def setlines (s, stflines, stfnum):
+if stfnum != s.curstaff:    # initialize for new staff
+s.curstaff = stfnum
+s.snaarVrij = []
+for i in range (stflines): s.snaarVrij.append ([])
+s.beginZoek ()
+def isVrij (s, snaar, t1, t2):  # see if string snaar is free between t1 and t2
+xs = s.snaarVrij [snaar]
+for i in range (s.snaarIx [snaar], len (xs)):
+tb, te = xs [i]
+if t1 >= te: continue   # te_prev < t1 <= te
+if t1 >= tb: s.snaarIx [snaar] = i; return 0    # tb <= t1 < te
+if t2 > tb: s.snaarIx [snaar] = i; return 0     # t1 < tb < t2
+s.snaarIx [snaar] = i;  # remember position for next call
+xs.insert (i, (t1,t2))  # te_prev < t1 < t2 < tb
+return 1
+xs.append ((t1,t2))
+s.snaarIx [snaar] = len (xs) - 1
+return 1
+def bezet (s, snaar, t1, t2):   # force allocation of note (t1,t2) on string snaar
+xs = s.snaarVrij [snaar]
+for i, (tb, te) in enumerate (xs):
+if t1 >= te: continue   # te_prev < t1 <= te
+xs.insert (i, (t1, t2))
+return
+xs.append ((t1,t2))
 class MusicXml:
 typeMap = {1:'long', 2:'breve', 4:'whole', 8:'half', 16:'quarter', 32:'eighth', 64:'16th', 128:'32nd', 256:'64th'}
-dynaMap = {'p':1,'pp':1,'ppp':1,'f':1,'ff':1,'fff':1,'mp':1,'mf':1,'sfz':1}
+dynaMap = {'p':1,'pp':1,'ppp':1,'pppp':1,'f':1,'ff':1,'fff':1,'ffff':1,'mp':1,'mf':1,'sfz':1}
+tempoMap = {'larghissimo':40, 'moderato':104, 'adagissimo':44, 'allegretto':112, 'lentissimo':48, 'allegro':120, 'largo':56,
+'vivace':168, 'adagio':59, 'vivo':180, 'lento':62, 'presto':192, 'larghetto':66, 'allegrissimo':208, 'adagietto':76,
+'vivacissimo':220, 'andante':88, 'prestissimo':240, 'andantino':96}
 wedgeMap = {'>(':1, '>)':1, '<(':1,'<)':1,'crescendo(':1,'crescendo)':1,'diminuendo(':1,'diminuendo)':1}
-artMap = {'.':'staccato','>':'accent','accent':'accent','wedge':'staccatissimo','tenuto':'tenuto'}
+artMap = {'.':'staccato','>':'accent','accent':'accent','wedge':'staccatissimo','tenuto':'tenuto',
+'breath':'breath-mark','marcato':'strong-accent','^':'strong-accent','slide':'scoop'}
 ornMap = {'trill':'trill-mark','T':'trill-mark','turn':'turn','uppermordent':'inverted-mordent','lowermordent':'mordent',
 'pralltriller':'inverted-mordent','mordent':'mordent','turn':'turn','invertedturn':'inverted-turn'}
-tecMap = {'upbow':'up-bow', 'downbow':'down-bow'}
+tecMap = {'upbow':'up-bow', 'downbow':'down-bow', 'plus':'stopped','open':'open-string','snap':'snap-pizzicato',
+'thumb':'thumb-position'}
 capoMap = {'fine':('Fine','fine','yes'), 'D.S.':('D.S.','dalsegno','segno'), 'D.C.':('D.C.','dacapo','yes'),'dacapo':('D.C.','dacapo','yes'),
 'dacoda':('To Coda','tocoda','coda'), 'coda':('coda','coda','coda'), 'segno':('segno','segno','segno')}
 sharpness = ['Fb', 'Cb','Gb','Db','Ab','Eb','Bb','F','C','G','D','A', 'E', 'B', 'F#','C#','G#','D#','A#','E#','B#']
 offTab = {'maj':8, 'm':11, 'min':11, 'mix':9, 'dor':10, 'phr':12, 'lyd':7, 'loc':13}
 modTab = {'maj':'major', 'm':'minor', 'min':'minor', 'mix':'mixolydian', 'dor':'dorian', 'phr':'phrygian', 'lyd':'lydian', 'loc':'locrian'}
 clefMap = { 'alto1':('C','1'), 'alto2':('C','2'), 'alto':('C','3'), 'alto4':('C','4'), 'tenor':('C','4'),
-'bass3':('F','3'), 'bass':('F','4'), 'treble':('G','2'), 'perc':('percussion',''), 'none':('','')}
+'bass3':('F','3'), 'bass':('F','4'), 'treble':('G','2'), 'perc':('percussion',''), 'none':('',''), 'tab':('TAB','5')}
 clefLineMap = {'B':'treble', 'G':'alto1', 'E':'alto2', 'C':'alto', 'A':'tenor', 'F':'bass3', 'D':'bass'}
 alterTab = {'=':'0', '_':'-1', '__':'-2', '^':'1', '^^':'2'}
 accTab = {'=':'natural', '_':'flat', '__':'flat-flat', '^':'sharp', '^^':'sharp-sharp'}
 chordTab = compChordTab ()
 uSyms = {'~':'roll', 'H':'fermata','L':'>','M':'lowermordent','O':'coda',
 'P':'uppermordent','S':'segno','T':'trill','u':'upbow','v':'downbow'}
-pageFmtDef = [1.764,297,210,10,10,10,10] # the MuseScore page formatting defaults for A4
+pageFmtDef = [0.75,297,210,18,18,10,10] # the abcm2ps page formatting defaults for A4
-creditTab = {'O':'origin', 'A':'area', 'Z':'transcription', 'N':'notes', 'G':'group', 'H':'history', 'R':'rhythm',
+metaTab = {'O':'origin', 'A':'area', 'Z':'transcription', 'N':'notes', 'G':'group', 'H':'history', 'R':'rhythm',
-'B':'book', 'D':'discography', 'F':'fileurl', 'S':'source'}
+'B':'book', 'D':'discography', 'F':'fileurl', 'S':'source', 'P':'partmap', 'W':'lyrics'}
+metaMap = {'C':'composer'}  # mapping of composer is fixed
+metaTypes = {'composer':1,'lyricist':1,'poet':1,'arranger':1,'translator':1, 'rights':1} # valid MusicXML meta data types
+tuningDef = 'E2,A2,D3,G3,B3,E4'.split (',') # default string tuning (guitar)
 def __init__ (s):
 s.pageFmtCmd = []   # set by command line option -p
-s.gmwr = 0          # set by command line option -r
 s.reset ()
-def reset (s):
+def reset (s, fOpt=False):
-s.divisions = 120   # xml duration of 1/4 note
+s.divisions = 2520  # xml duration of 1/4 note, 2^3 * 3^2 * 5 * 7 => 5,7,9 tuplets
 s.ties = {}         # {abc pitch tuple -> alteration} for all open ties
-s.slurstack = []    # stack of open slur numbers
+s.slurstack = {}    # stack of open slur numbers per (overlay) voice
-s.slurbeg = 0       # number of slurs to start (when slurs are detected at element-level)
+s.slurbeg = []      # type of slurs to start (when slurs are detected at element-level)
 s.tmnum = 0         # time modification, numerator
 s.tmden = 0         # time modification, denominator
 s.ntup = 0          # number of tuplet notes remaining
+s.trem = 0          # number of bars for tremolo
+s.intrem = 0        # mark tremolo sequence (for duration doubling)
 s.tupnts = []       # all tuplet modifiers with corresp. durations: [(duration, modifier), ...]
 s.irrtup = 0        # 1 if an irregular tuplet
 s.ntype = ''        # the normal-type of a tuplet (== duration type of a normal tuplet note)
 s.unitL =  (1, 8)   # default unit length
 s.unitLcur = (1, 8) # unit length of current voice
 s.keyAlts = {}      # alterations implied by key
 s.msreAlts = {}     # temporarily alterations
 s.curVolta = ''     # open volta bracket
-s.slurstack = []    # stack of open slur numbers
 s.title = ''        # title of music
 s.creator = {}      # {creator-type -> creator string}
-s.credits = {}      # {credit-type -> string}
+s.metadata = {}     # {metadata-type -> string}
 s.lyrdash = {}      # {lyric number -> 1 if dash between syllables}
 s.usrSyms = s.uSyms # user defined symbols
 s.prevNote = None   # xml element of previous beamed note to correct beams (start, continue)
+s.prevLyric = {}    # xml element of previous lyric to add/correct extend type (start, continue)
 s.grcbbrk = False   # remember any bbrk in a grace sequence
 s.linebrk = 0       # 1 if next measure should start with a line break
-s.bardecos = []     # barline decorations (coda, segno) that go into the next measure (MuseScore deficiency!)
 s.nextdecos = []    # decorations for the next note
 s.prevmsre = None   # the previous measure
 s.supports_tag = 0  # issue supports-tag in xml file when abc uses explicit linebreaks
 s.staveDefs = []    # collected %%staves or %%score instructions from score
 s.staves = []       # staves = [[voice names to be merged into one stave]]
 s.gStaffNums = {}   # map each voice id in a grand staff to a staff number
 s.gNstaves = {}     # map each voice id in a grand staff to total number of staves
 s.pageFmtAbc = []   # formatting from abc directives
 s.mdur = (4,4)      # duration of one measure
 s.gtrans = 0        # octave transposition (by clef)
-s.midprg = ['', ''] # MIDI channel nr, program nr for the current part
+s.midprg = ['', '', '', ''] # MIDI channel nr, program nr, volume, panning for the current part
-s.vid = ''          # abc voice id for the current part
+s.vid = ''          # abc voice id for the current voice
+s.pid = ''          # xml part id for the current voice
 s.gcue_on = 0       # insert <cue/> tag in each note
+s.percVoice = 0     # 1 if percussion enabled
+s.percMap = {}      # (part-id, abc_pitch, xml-octave) -> (abc staff step, midi note number, xml notehead)
+s.pMapFound = 0     # at least one I:percmap has been found
+s.vcepid = {}       # voice_id -> part_id
+s.midiInst = {}     # inst_id -> (part_id, voice_id, channel, midi_number), remember instruments used
+s.capo = 0          # fret position of the capodastro
+s.tunmid = []       # midi numbers of strings
+s.tunTup = []       # ordered midi numbers of strings [(midi_num, string_num), ...] (midi_num from high to low)
+s.fOpt = fOpt       # force string/fret allocations for tab staves
+s.orderChords = 0   # order notes in a chord
+s.chordDecos = {}   # decos that should be distributed to all chord notes for xml
+ch10 = 'acoustic-bass-drum,35;bass-drum-1,36;side-stick,37;acoustic-snare,38;hand-clap,39;electric-snare,40;low-floor-tom,41;closed-hi-hat,42;high-floor-tom,43;pedal-hi-hat,44;low-tom,45;open-hi-hat,46;low-mid-tom,47;hi-mid-tom,48;crash-cymbal-1,49;high-tom,50;ride-cymbal-1,51;chinese-cymbal,52;ride-bell,53;tambourine,54;splash-cymbal,55;cowbell,56;crash-cymbal-2,57;vibraslap,58;ride-cymbal-2,59;hi-bongo,60;low-bongo,61;mute-hi-conga,62;open-hi-conga,63;low-conga,64;high-timbale,65;low-timbale,66;high-agogo,67;low-agogo,68;cabasa,69;maracas,70;short-whistle,71;long-whistle,72;short-guiro,73;long-guiro,74;claves,75;hi-wood-block,76;low-wood-block,77;mute-cuica,78;open-cuica,79;mute-triangle,80;open-triangle,81'
+s.percsnd = [x.split (',') for x in ch10.split (';')]   # {name -> midi number} of standard channel 10 sound names
+s.gTime = (0,0)     # (XML begin time, XML end time) in divisions
+s.tabStaff = ''     # == pid (part ID) for a tab staff
 def mkPitch (s, acc, note, oct, lev):
+if s.percVoice: # percussion map switched off by perc=off (see doClef)
+octq = int (oct) + s.gtrans     # honour the octave= transposition when querying percmap
+tup = s.percMap.get ((s.pid, acc+note, octq), s.percMap.get (('', acc+note, octq), 0))
+if tup: step, soct, midi, notehead = tup
+else: step, soct = note, octq
+octnum = (4 if step.upper() == step else 5) + int (soct)
+if not tup: # add percussion map for unmapped notes in this part
+midi = str (octnum * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step.upper())] + {'^':1,'_':-1}.get (acc, 0) + 12)
+notehead = {'^':'x', '_':'circle-x'}.get (acc, 'normal')
+if s.pMapFound: info ('no I:percmap for: %s%s in part %s, voice %s' % (acc+note, -oct*',' if oct<0 else oct*"'", s.pid, s.vid))
+s.percMap [(s.pid, acc+note, octq)] =  (note, octq, midi, notehead)
+else:       # correct step value for clef
+step, octnum = stepTrans (step.upper (), octnum, s.curClef)
+pitch = E.Element ('unpitched')
+addElemT (pitch, 'display-step', step.upper (), lev + 1)
+addElemT (pitch, 'display-octave', str (octnum), lev + 1)
+return pitch, '', midi, notehead
 nUp = note.upper ()
 octnum = (4 if nUp == note else 5) + int (oct) + s.gtrans
 pitch = E.Element ('pitch')
 addElemT (pitch, 'step', nUp, lev + 1)
 alter = ''
 if (note, oct) in s.ties:
-tied_alter, _, vnum = s.ties [(note,oct)]               # vnum = overlay voice number when tie started
+tied_alter, _, vnum, _ = s.ties [(note,oct)]            # vnum = overlay voice number when tie started
 if vnum == s.overlayVnum: alter = tied_alter            # tied note in the same overlay -> same alteration
 elif acc:
 s.msreAlts [(nUp, octnum)] = s.alterTab [acc]
 alter = s.alterTab [acc]                                # explicit notated alteration
 elif (nUp, octnum) in s.msreAlts:   alter = s.msreAlts [(nUp, octnum)]  # temporary alteration
 elif nUp in s.keyAlts:              alter = s.keyAlts [nUp] # alteration implied by the key
 if alter: addElemT (pitch, 'alter', alter, lev + 1)
 addElemT (pitch, 'octave', str (octnum), lev + 1)
-return pitch, alter
+return pitch, alter, '', ''
+def getNoteDecos (s, n):
+decos = s.nextdecos             # decorations encountered so far
+ndeco = getattr (n, 'deco', 0)  # possible decorations of notes of a chord
+if ndeco:                       # add decorations, translate used defined symbols
+decos += [s.usrSyms.get (d, d).strip ('!+') for d in ndeco.t]
+s.nextdecos = []
+if s.tabStaff == s.pid and s.fOpt and n.name != 'rest':  # force fret/string allocation if explicit string decoration is missing
+if [d for d in decos if d in '0123456789'] == []: decos.append ('0')
+return decos
 def mkNote (s, n, lev):
+isgrace = getattr (n, 'grace', '')
+ischord = getattr (n, 'chord', '')
+if s.ntup >= 0 and not isgrace and not ischord:
+s.ntup -= 1                 # count tuplet notes only on non-chord, non grace notes
+if s.ntup == -1 and s.trem <= 0:
+s.intrem = 0            # tremolo pair ends at first note that is not a new tremolo pair (s.trem > 0)
 nnum, nden = n.dur.t            # abc dutation of note
+if s.intrem: nnum += nnum       # double duration of tremolo duplets
 if nden == 0: nden = 1          # occurs with illegal ABC like: "A2 1". Now interpreted as A2/1
 num, den = simplify (nnum * s.unitLcur[0], nden * s.unitLcur[1])  # normalised with unit length
 if den > 64:    # limit denominator to 64
 num = int (round (64 * float (num) / den))  # scale note to num/64
 num, den  = simplify (max ([num, 1]), 64)   # smallest num == 1
 info ('duration too small: rounded to %d/%d' % (num, den))
 if n.name == 'rest' and ('Z' in n.t or 'X' in n.t):
 num, den = s.mdur         # duration of one measure
-dvs = (4 * s.divisions * num) / den     # divisions is xml-duration of 1/4
+noMsrRest = not (n.name == 'rest' and (num, den) == s.mdur) # not a measure rest
+dvs = (4 * s.divisions * num) // den    # divisions is xml-duration of 1/4
 rdvs = dvs                      # real duration (will be 0 for chord/grace)
 num, den = simplify (num, den * 4)      # scale by 1/4 for s.typeMap
 ndot = 0
-if num == 3: ndot = 1; den = den / 2    # look for dotted notes
+if num == 3 and noMsrRest: ndot = 1; den = den // 2 # look for dotted notes
-if num == 7: ndot = 2; den = den / 4
+if num == 7 and noMsrRest: ndot = 2; den = den // 4
 nt = E.Element ('note')
-if getattr (n, 'grace', ''):    # a grace note (and possibly a chord note)
+if isgrace:                     # a grace note (and possibly a chord note)
 grace = E.Element ('grace')
 if s.acciatura: grace.set ('slash', 'yes'); s.acciatura = 0
 addElem (nt, grace, lev + 1)
 dvs = rdvs = 0              # no (real) duration for a grace note
 if den <= 16: den = 32      # not longer than 1/8 for a grace note
 if s.gcue_on:                   # insert cue tag
 cue = E.Element ('cue')
 addElem (nt, cue, lev + 1)
-if getattr (n, 'chord', ''):    # a chord note
+if ischord:                     # a chord note
 chord = E.Element ('chord')
 addElem (nt, chord, lev + 1)
 rdvs = 0                    # chord notes no real duration
-if rdvs and s.ntup >= 0: s.ntup -= 1    # count tuplet notes only on non-chord, non grace notes (rdvs > 0)
 if den not in s.typeMap:        # take the nearest smaller legal duration
 info ('illegal duration %d/%d' % (nnum, nden))
 den = min (x for x in s.typeMap.keys () if x > den)
 xmltype = str (s.typeMap [den]) # xml needs the note type in addition to duration
 acc, step, oct = '', 'C', '0'   # abc-notated pitch elements (accidental, pitch step, octave)
-alter = ''                      # xml alteration
+alter, midi, notehead = '', '', ''      # xml alteration
 if n.name == 'rest':
 if 'x' in n.t or 'X' in n.t: nt.set ('print-object', 'no')
 rest = E.Element ('rest')
+if not noMsrRest: rest.set ('measure', 'yes')
 addElem (nt, rest, lev + 1)
 else:
 p = n.pitch.t           # get pitch elements from parsed tokens
 if len (p) == 3:    acc, step, oct = p
 else:               step, oct = p
-pitch, alter = s.mkPitch (acc, step, oct, lev + 1)
+pitch, alter, midi, notehead = s.mkPitch (acc, step, oct, lev + 1)
+if midi: acc = ''       # erase accidental for percussion notes
 addElem (nt, pitch, lev + 1)
 if s.ntup >= 0:                 # modify duration for tuplet notes
-dvs = dvs * s.tmden / s.tmnum
+dvs = dvs * s.tmden // s.tmnum
-if dvs: addElemT (nt, 'duration', str (dvs), lev + 1)   # skip when dvs == 0, requirement of musicXML
+if dvs:
-inst = E.Element ('instrument', id='I-'+s.vid)          # instrument id for midi
+addElemT (nt, 'duration', str (dvs), lev + 1)   # skip when dvs == 0, requirement of musicXML
-if s.midprg != ['', '']: addElem (nt, inst, lev + 1)    # only add when %%midi was present
+if not ischord: s.gTime = s.gTime [1], s.gTime [1] + dvs
+ptup = (step, oct)              # pitch tuple without alteration to check for ties
+tstop = ptup in s.ties and s.ties[ptup][2] == s.overlayVnum  # open tie on this pitch tuple in this overlay
+if tstop:
+tie = E.Element ('tie', type='stop')
+addElem (nt, tie, lev + 1)
+if getattr (n, 'tie', 0):
+tie = E.Element ('tie', type='start')
+addElem (nt, tie, lev + 1)
+if (s.midprg != ['', '', '', ''] or midi) and n.name != 'rest': # only add when %%midi was present or percussion
+instId = 'I%s-%s' % (s.pid, 'X' + midi if midi else s.vid)
+chan, midi = ('10', midi) if midi else s.midprg [:2]
+inst = E.Element ('instrument', id=instId)  # instrument id for midi
+addElem (nt, inst, lev + 1)
+if instId not in s.midiInst: s.midiInst [instId] = (s.pid, s.vid, chan, midi, s.midprg [2], s.midprg [3]) # for instrument list in mkScorePart
 addElemT (nt, 'voice', '1', lev + 1)    # default voice, for merging later
-addElemT (nt, 'type', xmltype, lev + 1) # add note type
+if noMsrRest: addElemT (nt, 'type', xmltype, lev + 1) # add note type if not a measure rest
 for i in range (ndot):          # add dots
 dot = E.Element ('dot')
 addElem (nt, dot, lev + 1)
-ptup = (step, oct)              # pitch tuple without alteration to check for ties
+decos = s.getNoteDecos (n)      # get decorations for this note
-tstop = ptup in s.ties and s.ties[ptup][2] == s.overlayVnum  # open tie on this pitch tuple in this overlay
+if acc and not tstop:           # only add accidental if note not tied
-if acc and not tstop: addElemT (nt, 'accidental', s.accTab [acc], lev + 1) # only add accidental if note not tied
+e = E.Element ('accidental')
+if 'courtesy' in decos:
+e.set ('parentheses', 'yes')
+decos.remove ('courtesy')
+e.text = s.accTab [acc]
+addElem (nt, e, lev + 1)
 tupnotation = ''                # start/stop notation element for tuplets
 if s.ntup >= 0:                 # add time modification element for tuplet notes
 tmod = mkTmod (s.tmnum, s.tmden, lev + 1)
 addElem (nt, tmod, lev + 1)
 if s.ntup > 0 and not s.tupnts: tupnotation = 'start'
 s.tupnts.append ((rdvs, tmod))      # remember all tuplet modifiers with corresp. durations
 if s.ntup == 0:             # last tuplet note (and possible chord notes there after)
 if rdvs: tupnotation = 'stop'   # only insert notation in the real note (rdvs > 0)
 s.cmpNormType (rdvs, lev + 1)   # compute and/or add normal-type elements (-> s.ntype)
+hasStem = 1
+if not ischord: s.chordDecos = {}       # clear on non chord note
+if 'stemless' in decos or (s.nostems and n.name != 'rest') or 'stemless' in s.chordDecos:
+hasStem = 0
+addElemT (nt, 'stem', 'none', lev + 1)
+if 'stemless' in decos: decos.remove ('stemless')   # do not handle in doNotations
+if hasattr (n, 'pitches'): s.chordDecos ['stemless'] = 1    # set on first chord note
+if notehead:
+nh = addElemT (nt, 'notehead', re.sub (r'[+-]$', '', notehead), lev + 1)
+if notehead[-1] in '+-': nh.set ('filled', 'yes' if notehead[-1] == '+' else 'no')
 gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
 if gstaff: addElemT (nt, 'staff', str (gstaff), lev + 1)
-s.doBeams (n, nt, den, lev + 1)
+if hasStem: s.doBeams (n, nt, den, lev + 1)   # no stems -> no beams in a tab staff
-s.doNotations (n, ptup, alter, tupnotation, tstop, nt, lev + 1)
+s.doNotations (n, decos, ptup, alter, tupnotation, tstop, nt, lev + 1)
 if n.objs: s.doLyr (n, nt, lev + 1)
+else: s.prevLyric = {}   # clear on note without lyrics
 return nt
 def cmpNormType (s, rdvs, lev): # compute the normal-type of a tuplet (only needed for Finale)
 if rdvs:    # the last real tuplet note (chord notes can still follow afterwards with rdvs == 0)
 durs = [dur for dur, tmod in s.tupnts if dur > 0]
-ndur = sum (durs) / s.tmnum # duration of the normal type
+ndur = sum (durs) // s.tmnum    # duration of the normal type
 s.irrtup = any ((dur != ndur) for dur in durs)  # irregular tuplet
-tix = 16 * s.divisions / ndur       # index in typeMap of normal-type duration
+tix = 16 * s.divisions // ndur  # index in typeMap of normal-type duration
 if tix in s.typeMap:
 s.ntype = str (s.typeMap [tix]) # the normal-type
 else: s.irrtup = 0          # give up, no normal type possible
 if s.irrtup:                    # only add normal-type for irregular tuplets
 for dur, tmod in s.tupnts:  # add normal-type to all modifiers
 addElemT (tmod, 'normal-type', s.ntype, lev + 1)
 s.tupnts = []                   # reset the tuplet buffer
-def doNotations (s, n, ptup, alter, tupnotation, tstop, nt, lev):
+def doNotations (s, n, decos, ptup, alter, tupnotation, tstop, nt, lev):
 slurs = getattr (n, 'slurs', 0) # slur ends
 pts = getattr (n, 'pitches', [])            # all chord notes available in the first note
+ov = s.overlayVnum                          # current overlay voice number (0 for the main voice)
 if pts:                                     # make list of pitches in chord: [(pitch, octave), ..]
 if type (pts.pitch) == pObj: pts = [pts.pitch]      # chord with one note
 else: pts = [tuple (p.t[-2:]) for p in pts.pitch]   # normal chord
-for pt, (tie_alter, nts, vnum) in s.ties.items ():      # scan all open ties and delete illegal ones
+for pt, (tie_alter, nts, vnum, ntelm) in sorted (list (s.ties.items ())):  # scan all open ties and delete illegal ones
 if vnum != s.overlayVnum: continue      # tie belongs to different overlay
 if pts and pt in pts: continue          # pitch tuple of tie exists in chord
 if getattr (n, 'chord', 0): continue    # skip chord notes
 if pt == ptup: continue                 # skip correct single note tie
 if getattr (n, 'grace', 0): continue    # skip grace notes
 info ('tie between different pitches: %s%s converted to slur' % pt)
 del s.ties [pt]                         # remove the note from pending ties
-e = [t for t in nts.findall ('tied') if t.get ('type') == 'start'][0]   # get the tie start element
+e = [t for t in ntelm.findall ('tie') if t.get ('type') == 'start'][0]  # get the tie start element
+ntelm.remove (e)                        # delete start tie element
+e = [t for t in nts.findall ('tied') if t.get ('type') == 'start'][0]   # get the tied start element
 e.tag = 'slur'                          # convert tie into slur
-slurnum = len (s.slurstack) + 1
+slurnum = pushSlur (s.slurstack, ov)
-s.slurstack.append (slurnum)
 e.set ('number', str (slurnum))
 if slurs: slurs.t.append (')')          # close slur on this note
 else: slurs = pObj ('slurs', [')'])
 tstart = getattr (n, 'tie', 0)  # start a new tie
-decos = s.nextdecos     # decorations encountered so far
+if not (tstop or tstart or decos or slurs or s.slurbeg or tupnotation or s.trem): return nt
-ndeco = getattr (n, 'deco', 0)  # possible decorations of notes of a chord
-if ndeco:               # add decorations, translate used defined symbols
-decos += [s.usrSyms.get (d, d).strip ('!+') for d in ndeco.t]
-s.nextdecos = []
-if not (tstop or tstart or decos or slurs or s.slurbeg or tupnotation): return nt
 nots = E.Element ('notations')  # notation element needed
-if tupnotation:         # add tuplet type
+if s.trem:  # +/- => tuple tremolo sequence / single note tremolo
+if s.trem < 0: tupnotation = 'single'; s.trem = -s.trem
+if not tupnotation: return  # only add notation at first or last note of a tremolo sequence
+orn = E.Element ('ornaments')
+trm = E.Element ('tremolo', type=tupnotation)   # type = start, stop or single
+trm.text = str (s.trem)     # the number of bars in a tremolo note
+addElem (nots, orn, lev + 1)
+addElem (orn, trm, lev + 2)
+if tupnotation == 'stop' or tupnotation == 'single': s.trem = 0
+elif tupnotation:       # add tuplet type
 tup = E.Element ('tuplet', type=tupnotation)
 if tupnotation == 'start': tup.set ('bracket', 'yes')
 addElem (nots, tup, lev + 1)
 if tstop:               # stop tie
 del s.ties[ptup]    # remove flag
 tie = E.Element ('tied', type='stop')
 addElem (nots, tie, lev + 1)
 if tstart:              # start a tie
-s.ties[ptup] = (alter, nots, s.overlayVnum) # remember pitch tuple to stop tie and apply same alteration
+s.ties[ptup] = (alter, nots, s.overlayVnum, nt) # remember pitch tuple to stop tie and apply same alteration
 tie = E.Element ('tied', type='start')
+if tstart.t[0] == '.-': tie.set ('line-type', 'dotted')
 addElem (nots, tie, lev + 1)
 if decos:               # look for slurs and decorations
+slurMap = { '(':1, '.(':1, '(,':1, "('":1, '.(,':1, ".('":1 }
 arts = []           # collect articulations
 for d in decos:     # do all slurs and decos
-if d == '(': s.slurbeg += 1; continue # slurs made in while loop at the end
+if d in slurMap: s.slurbeg.append (d); continue # slurs made in while loop at the end
 elif d == 'fermata' or d == 'H':
 ntn = E.Element ('fermata', type='upright')
 elif d == 'arpeggio':
 ntn = E.Element ('arpeggiate', number='1')
+elif d in ['~(', '~)']:
+if d[1] == '(': tp = 'start'; s.glisnum += 1; gn = s.glisnum
+else:           tp = 'stop'; gn = s.glisnum; s.glisnum -= 1
+if s.glisnum < 0: s.glisnum = 0; continue   # stop without previous start
+ntn = E.Element ('glissando', {'line-type':'wavy', 'number':'%d' % gn, 'type':tp})
+elif d in ['-(', '-)']:
+if d[1] == '(': tp = 'start'; s.slidenum += 1; gn = s.slidenum
+else:           tp = 'stop'; gn = s.slidenum; s.slidenum -= 1
+if s.slidenum < 0: s.slidenum = 0; continue   # stop without previous start
+ntn = E.Element ('slide', {'line-type':'solid', 'number':'%d' % gn, 'type':tp})
 else: arts.append (d); continue
 addElem (nots, ntn, lev + 1)
 if arts:        # do only note articulations and collect staff annotations in xmldecos
-rest = s.doArticulations (nots, arts, lev + 1)
+rest = s.doArticulations (nt, nots, arts, lev + 1)
 if rest: info ('unhandled note decorations: %s' % rest)
-while s.slurbeg > 0:
-s.slurbeg -= 1
-slurnum = len (s.slurstack) + 1
-s.slurstack.append (slurnum)
-ntn = E.Element ('slur', number='%d' % slurnum, type='start')
-addElem (nots, ntn, lev + 1)
 if slurs:           # these are only slur endings
-for d in slurs.t:
+for d in slurs.t:           # slurs to be closed on this note
-if not s.slurstack: break   # no more open slurs
+if not s.slurstack.get (ov, 0): break    # no more open old slurs for this (overlay) voice
-slurnum = s.slurstack.pop ()
+slurnum = s.slurstack [ov].pop ()
 slur = E.Element ('slur', number='%d' % slurnum, type='stop')
 addElem (nots, slur, lev + 1)
-if nots.getchildren() != []:        # only add notations if not empty
+while s.slurbeg:    # create slurs beginning on this note
+stp = s.slurbeg.pop (0)
+slurnum = pushSlur (s.slurstack, ov)
+ntn = E.Element ('slur', number='%d' % slurnum, type='start')
+if '.' in stp: ntn.set ('line-type', 'dotted')
+if ',' in stp: ntn.set ('placement', 'below')
+if "'" in stp: ntn.set ('placement', 'above')
+addElem (nots, ntn, lev + 1)
+if list (nots) != []:    # only add notations if not empty
 addElem (nt, nots, lev)
-def doArticulations (s, nots, arts, lev):
+def doArticulations (s, nt, nots, arts, lev):
 decos = []
 for a in arts:
 if a in s.artMap:
 art = E.Element ('articulations')
 addElem (nots, art, lev)
 addElem (art, E.Element (s.artMap[a]), lev + 1)
 elif a in s.ornMap:
 orn = E.Element ('ornaments')
 addElem (nots, orn, lev)
 addElem (orn, E.Element (s.ornMap[a]), lev + 1)
+elif a in ['trill(','trill)']:
+orn = E.Element ('ornaments')
+addElem (nots, orn, lev)
+type = 'start' if a.endswith ('(') else 'stop'
+if type == 'start': addElem (orn, E.Element ('trill-mark'), lev + 1)
+addElem (orn, E.Element ('wavy-line', type=type), lev + 1)
 elif a in s.tecMap:
 tec = E.Element ('technical')
 addElem (nots, tec, lev)
 addElem (tec, E.Element (s.tecMap[a]), lev + 1)
+elif a in '0123456':
+tec = E.Element ('technical')
+addElem (nots, tec, lev)
+if s.tabStaff == s.pid:             # current voice belongs to a tabStaff
+alt = int (nt.findtext ('pitch/alter') or 0)    # find midi number of current note
+step = nt.findtext ('pitch/step')
+oct = int (nt.findtext ('pitch/octave'))
+midi = oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step)] + alt + 12
+if a == '0':                    # no string annotation: find one
+firstFit = ''
+for smid, istr in s.tunTup: # midi numbers of open strings from high to low
+if midi >= smid:        # highest open string where this note can be played
+isvrij = s.strAlloc.isVrij (istr - 1, s.gTime [0], s.gTime [1])
+a = str (istr)      # string number
+if not firstFit: firstFit = a
+if isvrij: break
+if not isvrij:              # no free string, take the first fit (lowest fret)
+a = firstFit
+s.strAlloc.bezet (int (a) - 1, s.gTime [0], s.gTime [1])
+else:                           # force annotated string number
+s.strAlloc.bezet (int (a) - 1, s.gTime [0], s.gTime [1])
+bmidi = s.tunmid [int (a) - 1]  # midi number of allocated string (with capodastro)
+fret =  midi - bmidi            # fret position (respecting capodastro)
+if fret < 25 and fret >= 0:
+addElemT (tec, 'fret', str (fret), lev + 1)
+else:
+altp = 'b' if alt == -1 else '#' if alt == 1 else ''
+info ('fret %d out of range, note %s%d on string %s' % (fret, step+altp, oct, a))
+addElemT (tec, 'string', a, lev + 1)
+else:
+addElemT (tec, 'fingering', a, lev + 1)
 else: decos.append (a)  # return staff annotations
 return decos
 def doLyr (s, n, nt, lev):
 for i, lyrobj in enumerate (n.objs):
-if lyrobj.name != 'syl': continue
-dash = len (lyrobj.t) == 2
-if dash:
-if i in s.lyrdash:  type = 'middle'
-else:               type = 'begin'; s.lyrdash [i] = 1
-else:
-if i in s.lyrdash:  type = 'end';   del s.lyrdash [i]
-else:               type = 'single'
 lyrel = E.Element ('lyric', number = str (i + 1))
+if lyrobj.name == 'syl':
+dash = len (lyrobj.t) == 2
+if dash:
+if i in s.lyrdash:  type = 'middle'
+else:               type = 'begin'; s.lyrdash [i] = 1
+else:
+if i in s.lyrdash:  type = 'end';   del s.lyrdash [i]
+else:               type = 'single'
+addElemT (lyrel, 'syllabic', type, lev + 1)
+txt = lyrobj.t[0]                       # the syllabe
+txt = re.sub (r'(?<!\\)~', ' ', txt)    # replace ~ by space when not escaped (preceded by \)
+txt = re.sub (r'\\(.)', r'\1', txt)     # replace all escaped characters by themselves (for the time being)
+addElemT (lyrel, 'text', txt, lev + 1)
+elif lyrobj.name == 'ext' and i in s.prevLyric:
+pext = s.prevLyric [i].find ('extend')  # identify previous extend
+if pext == None:
+ext = E.Element ('extend', type = 'start')
+addElem (s.prevLyric [i], ext, lev + 1)
+elif pext.get('type') == 'stop':        # subsequent extend: stop -> continue
+pext.set ('type', 'continue')
+ext = E.Element ('extend', type = 'stop')   # always stop on current extend
+addElem (lyrel, ext, lev + 1)
+elif lyrobj.name == 'ext': info ('lyric extend error'); continue
+else: continue          # skip other lyric elements or errors
 addElem (nt, lyrel, lev)
-addElemT (lyrel, 'syllabic', type, lev + 1)
+s.prevLyric [i] = lyrel # for extension (melisma) on the next note
-addElemT (lyrel, 'text', lyrobj.t[0].replace ('~',' '), lev + 1)
 def doBeams (s, n, nt, den, lev):
 if hasattr (n, 'chord') or hasattr (n, 'grace'):
 s.grcbbrk = s.grcbbrk or n.bbrk.t[0]    # remember if there was any bbrk in or before a grace sequence
 return
 s.prevNote.remove (pbm)
 elif pbm.text == 'continue':
 pbm.text = 'end'
 s.prevNote = None
-def staffDecos (s, decos, maat, lev, bardecos=0):
+def staffDecos (s, decos, maat, lev):
 gstaff = s.gStaffNums.get (s.vid, 0)        # staff number of the current voice
 for d in decos:
 d = s.usrSyms.get (d, d).strip ('!+')   # try to replace user defined symbol
 if d in s.dynaMap:
 dynel = E.Element ('dynamics')
 addDirection (maat, dynel, lev, gstaff, [E.Element (d)], 'below', s.gcue_on)
 elif d in s.wedgeMap:  # wedge
 if ')' in d: type = 'stop'
 else: type = 'crescendo' if '<' in d or 'crescendo' in d else 'diminuendo'
 addDirection (maat, E.Element ('wedge', type=type), lev, gstaff)
+elif d.startswith ('8v'):
+if 'a' in d: type, plce = 'down', 'above'
+else:        type, plce = 'up', 'below'
+if ')' in d: type = 'stop'
+addDirection (maat, E.Element ('octave-shift', type=type, size='8'), lev, gstaff, placement=plce)
+elif d in (['ped','ped-up']):
+type = 'stop' if d.endswith ('up') else 'start'
+addDirection (maat, E.Element ('pedal', type=type), lev, gstaff)
 elif d in ['coda', 'segno']:
-if bardecos: s.bardecos.append (d)  # postpone to begin next measure
+text, attr, val = s.capoMap [d]
-else:
+dir = addDirection (maat, E.Element (text), lev, gstaff, placement='above')
-text, attr, val = s.capoMap [d]
+sound = E.Element ('sound'); sound.set (attr, val)
-dir = addDirection (maat, E.Element (text), lev, gstaff, placement='above')
+addElem (dir, sound, lev + 1)
-sound = E.Element ('sound'); sound.set (attr, val)
-addElem (dir, sound, lev + 1)
 elif d in s.capoMap:
 text, attr, val = s.capoMap [d]
 words = E.Element ('words'); words.text = text
 dir = addDirection (maat, words, lev, gstaff, placement='above')
 sound = E.Element ('sound'); sound.set (attr, val)
 addElem (dir, sound, lev + 1)
-elif d == '(': s.slurbeg += 1   # start slur on next note
+elif d == '(' or d == '.(': s.slurbeg.append (d)   # start slur on next note
+elif d in ['/-','//-','///-','////-']:  # duplet tremolo sequence
+s.tmnum, s.tmden, s.ntup, s.trem, s.intrem = 2, 1, 2, len (d) - 1, 1
+elif d in ['/','//','///']: s.trem = - len (d)  # single note tremolo
 else: s.nextdecos.append (d)    # keep annotation for the next note
 def doFields (s, maat, fieldmap, lev):
-def doClef ():
+def instDir (midelm, midnum, dirtxt):
+instId = 'I%s-%s' % (s.pid, s.vid)
+words = E.Element ('words'); words.text = dirtxt % midnum
+snd = E.Element ('sound')
+mi = E.Element ('midi-instrument', id=instId)
+dir = addDirection (maat, words, lev, gstaff, placement='above')
+addElem (dir, snd, lev + 1)
+addElem (snd, mi, lev + 2)
+addElemT (mi, midelm, midnum, lev + 3)
+def addTrans (n):
+e = E.Element ('transpose')
+addElemT (e, 'chromatic', n, lev + 2)  # n == signed number string given after transpose
+atts.append ((9, e))
+def doClef (field):
+if re.search (r'perc|map', field):  # percussion clef or new style perc=on or map=perc
+r = re.search (r'(perc|map)\s*=\s*(\S*)', field)
+s.percVoice = 0 if r and r.group (2) not in ['on','true','perc'] else 1
+field = re.sub (r'(perc|map)\s*=\s*(\S*)', '', field)   # erase the perc= for proper clef matching
 clef, gtrans = 0, 0
-clefn = re.search (r'alto1|alto2|alto4|alto|tenor|bass3|bass|treble|perc|none', field)
+clefn = re.search (r'alto1|alto2|alto4|alto|tenor|bass3|bass|treble|perc|none|tab', field)
 clefm = re.search (r"(?:^m=| m=|middle=)([A-Ga-g])([,']*)", field)
-trans_oct2 = re.search (r'octave=([-+]\d)', field)
+trans_oct2 = re.search (r'octave=([-+]?\d)', field)
 trans = re.search (r'(?:^t=| t=|transpose=)(-?[\d]+)', field)
 trans_oct = re.search (r'([+-^_])(8|15)', field)
 cue_onoff = re.search (r'cue=(on|off)', field)
+strings = re.search (r"strings=(\S+)", field)
+stafflines = re.search (r'stafflines=\s*(\d)', field)
+capo = re.search (r'capo=(\d+)', field)
 if clefn:
 clef = clefn.group ()
 if clefm:
 note, octstr = clefm.groups ()
 nUp = note.upper ()
 octnum = (4 if nUp == note else 5) + (len (octstr) if "'" in octstr else -len (octstr))
 gtrans = (3 if nUp in 'AFD' else 4) - octnum
 if clef not in ['perc', 'none']: clef = s.clefLineMap [nUp]
 if clef:
 s.gtrans = gtrans   # only change global tranposition when a clef is really defined
+if clef != 'none': s.curClef = clef       # keep track of current abc clef (for percmap)
 sign, line = s.clefMap [clef]
 if not sign: return
 c = E.Element ('clef')
-gstaff = s.gStaffNums.get (s.vid, 0)        # the current staff number
 if gstaff: c.set ('number', str (gstaff))   # only add staff number when defined
 addElemT (c, 'sign', sign, lev + 2)
 if line: addElemT (c, 'line', line, lev + 2)
 if trans_oct:
 n = trans_oct.group (1) in '-_' and -1 or 1
 if trans_oct.group (2) == '15': n *= 2  # 8 => 1 octave, 15 => 2 octaves
 addElemT (c, 'clef-octave-change', str (n), lev + 2) # transpose print out
 if trans_oct.group (1) in '+-': s.gtrans += n   # also transpose all pitches with one octave
-if trans_oct2:
-n = int (trans_oct2.group (1))
-s.gtrans += n
 atts.append ((7, c))
+if trans_oct2:  # octave= can also be in a K: field
+n = int (trans_oct2.group (1))
+s.gtrans = gtrans + n
 if trans != None:   # add transposition in semitones
 e = E.Element ('transpose')
 addElemT (e, 'chromatic', str (trans.group (1)), lev + 3)
 atts.append ((9, e))
 if cue_onoff: s.gcue_on = cue_onoff.group (1) == 'on'
+nlines = 0
+if clef == 'tab':
+s.tabStaff = s.pid
+if capo: s.capo = int (capo.group (1))
+if strings: s.tuning = strings.group (1).split (',')
+s.tunmid = [int (boct) * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (bstep)] + 12 + s.capo for bstep, boct in s.tuning]
+s.tunTup = sorted (zip (s.tunmid, range (len (s.tunmid), 0, -1)), reverse=1)
+s.tunmid.reverse ()
+nlines = str (len (s.tuning))
+s.strAlloc.setlines (len (s.tuning), s.pid)
+s.nostems = 'nostems' in field  # tab clef without stems
+s.diafret = 'diafret' in field  # tab with diatonic fretting
+if stafflines or nlines:
+e = E.Element ('staff-details')
+if gstaff: e.set ('number', str (gstaff))   # only add staff number when defined
+if not nlines: nlines = stafflines.group (1)
+addElemT (e, 'staff-lines', nlines, lev + 2)
+if clef == 'tab':
+for line, t in enumerate (s.tuning):
+st = E.Element ('staff-tuning', line=str(line+1))
+addElemT (st, 'tuning-step', t[0], lev + 3)
+addElemT (st, 'tuning-octave', t[1], lev + 3)
+addElem (e, st, lev + 2)
+if s.capo: addElemT (e, 'capo', str (s.capo), lev + 2)
+atts.append ((8, e))
+s.diafret = 0           # chromatic fretting is default
 atts = []               # collect xml attribute elements [(order-number, xml-element), ..]
+gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
 for ftype, field in fieldmap.items ():
 if not field:       # skip empty fields
 continue
 if ftype == 'Div':  # not an abc field, but handled as if
 d = E.Element ('divisions')
 for step, alter in alts:                # correct permanent alterations for this key
 s.keyAlts [step.upper ()] = alter
 k = E.Element ('key')
 koctave = []
 lowerCaseSteps = [step.upper () for step, alter in alts if step.islower ()]
-for step, alter in s.keyAlts.items ():
+for step, alter in sorted (list (s.keyAlts.items ())):
 if alter == '0':                    # skip neutrals
 del s.keyAlts [step.upper ()]   # otherwise you get neutral signs on normal notes
 continue
 addElemT (k, 'key-step', step.upper (), lev + 2)
 addElemT (k, 'key-alter', alter, lev + 2)
 elif mode:
 k = E.Element ('key')
 addElemT (k, 'fifths', str (fifths), lev + 2)
 addElemT (k, 'mode', s.modTab [mode], lev + 2)
 atts.append ((2, k))
-doClef ()
+doClef (field)
 elif ftype == 'L':
-s.unitLcur = map (int, field.split ('/'))
+try: s.unitLcur = lmap (int, field.split ('/'))
+except: s.unitLcur = (1,8)
 if len (s.unitLcur) == 1 or s.unitLcur[1] not in s.typeMap:
 info ('L:%s is not allowed, 1/8 assumed' % field)
 s.unitLcur = 1,8
 elif ftype == 'V':
-doClef ()
+doClef (field)
 elif ftype == 'I':
-xs = s.doField_I (ftype, field)
+s.doField_I (ftype, field, instDir, addTrans)
-if xs and len (xs) == 1:    # when "%%MIDI transpose" matched insert 'attribute/transpose/chromatic'
-e = E.Element ('transpose')
-addElemT (e, 'chromatic', xs[0], lev + 2)  # xs[0] == signed number string given after transpose
-atts.append ((9, e))
-if xs and len (xs) == 2:    # repeated occurrence of [I:MIDI] -> instrument change
-midchan, midprog = xs
-snd = E.Element ('sound')
-mi = E.Element ('midi-instrument', id='I-' + s.vid)
-addElem (maat, snd, lev)
-addElem (snd, mi, lev + 1)
-if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2)
-if midprog: addElemT (mi, 'midi-program', str (int (midprog) + 1), lev + 2) # compatible with abc2midi
 elif ftype == 'Q':
 s.doTempo (maat, field, lev)
+elif ftype == 'P':  # ad hoc translation of P: into a staff text direction
+words = E.Element ('rehearsal')
+words.set ('font-weight', 'bold')
+words.text = field
+addDirection (maat, words, lev, gstaff, placement='above')
 elif ftype in 'TCOAZNGHRBDFSU':
 info ('**illegal header field in body: %s, content: %s' % (ftype, field))
 else:
 info ('unhandled field: %s, content: %s' % (ftype, field))
 if atts:
 att = E.Element ('attributes')      # insert sub elements in the order required by musicXML
 addElem (maat, att, lev)
-for _, att_elem in sorted (atts):   # ordering !
+for _, att_elem in sorted (atts, key=lambda x: x[0]):   # ordering !
 addElem (att, att_elem, lev + 1)
+if s.diafret:
+other = E.Element ('other-direction'); other.text = 'diatonic fretting'
+addDirection (maat, other, lev, 0)
 def doTempo (s, maat, field, lev):
 gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
-t = re.search (r'(\d)/(\d\d?)\s*=\s*([.\d]+)|([.\d]+)', field)
+t = re.search (r'(\d)/(\d\d?)\s*=\s*(\d[.\d]*)|(\d[.\d]*)', field)
-if not t: return
+rtxt = re.search (r'"([^"]*)"', field) # look for text in Q: field
-try:
+if not t and not rtxt: return
-if t.group (4):
+elems = []  # [(element, sub-elements)] will be added as direction-types
-num, den, upm = 1, s.unitLcur[1] , float (t.group (4))
+if rtxt:
-else:
+num, den, upm = 1, 4, s.tempoMap.get (rtxt.group (1).lower ().strip (), 120)
-num, den, upm = int (t.group (1)), int (t.group (2)), float (t.group (3))
+words = E.Element ('words'); words.text = rtxt.group (1)
-except: return  # float or int conversion failure
+elems.append ((words, []))
-if num != 1: info ('in Q: numerator > 1 in %d/%d not supported' % (num, den))
+if t:
+try:
+if t.group (4): num, den, upm = 1, s.unitLcur[1] , float (t.group (4))  # old syntax Q:120
+else:           num, den, upm = int (t.group (1)), int (t.group (2)), float (t.group (3))
+except: info ('conversion error: %s' % field); return
+num, den = simplify (num, den);
+dotted, den_not = (1, den // 2) if num == 3 else (0, den)
+metro = E.Element ('metronome')
+u = E.Element ('beat-unit'); u.text = s.typeMap.get (4 * den_not, 'quarter')
+pm = E.Element ('per-minute'); pm.text = ('%.2f' % upm).rstrip ('0').rstrip ('.')
+subelms = [u, E.Element ('beat-unit-dot'), pm] if dotted else [u, pm]
+elems.append ((metro, subelms))
+dir = addDirection (maat, elems, lev, gstaff, [], placement='above')
+if num != 1 and num != 3: info ('in Q: numerator in %d/%d not supported' % (num, den))
 qpm = 4. * num * upm / den
-metro = E.Element ('metronome')
-u = E.Element ('beat-unit'); u.text = s.typeMap [4 * den]
-pm = E.Element ('per-minute'); pm.text = '%.2f' % upm
-dir = addDirection (maat, metro, lev, gstaff, [u, pm], placement='above')
 sound = E.Element ('sound'); sound.set ('tempo', '%.2f' % qpm)
 addElem (dir, sound, lev + 1)
 def mkBarline (s, maat, loc, lev, style='', dir='', ending=''):
 b = E.Element ('barline', location=loc)
 addElem (maat, chord, lev)
 root = E.Element ('root')
 addElem (chord, root, lev + 1)
 addElemT (root, 'root-step', rnt[0], lev + 2)
 if len (rnt) == 2: addElemT (root, 'root-alter', alterMap [rnt[1]], lev + 2)
-kind = s.chordTab.get (sym.kind.t[0], 'major')
+kind = s.chordTab.get (sym.kind.t[0], 'major') if sym.kind.t else 'major'
 addElemT (chord, 'kind', kind, lev + 1)
+if hasattr (sym, 'bass'):
+bnt = sym.bass.t
+bass = E.Element ('bass')
+addElem (chord, bass, lev + 1)
+addElemT (bass, 'bass-step', bnt[0], lev + 2)
+if len (bnt) == 2: addElemT (bass, 'bass-alter', alterMap [bnt[1]], lev + 2)
 degs = getattr (sym, 'degree', '')
 if degs:
-if type (degs) != types.ListType: degs = [degs]
+if type (degs) != list_type: degs = [degs]
 for deg in degs:
 deg = deg.t[0]
 if deg[0] == '#':   alter = '1';  deg = deg[1:]
 elif deg[0] == 'b': alter = '-1'; deg = deg[1:]
 else:               alter = '0';  deg = deg
 addElemT (degree, 'degree-alter', alter, lev + 2)
 addElemT (degree, 'degree-type', 'add', lev + 2)
 def mkMeasure (s, i, t, lev, fieldmap={}):
 s.msreAlts = {}
-s.ntup = -1
+s.ntup, s.trem, s.intrem = -1, 0, 0
 s.acciatura = 0 # next grace element gets acciatura attribute
 overlay = 0
 maat = E.Element ('measure', number = str(i))
 if fieldmap: s.doFields (maat, fieldmap, lev + 1)
 if s.linebrk:   # there was a line break in the previous measure
 e = E.Element ('print')
 e.set ('new-system', 'yes')
 addElem (maat, e, lev + 1)
 s.linebrk = 0
-if s.bardecos:  # output coda and segno attached to the previous right barline
-s.staffDecos (s.bardecos, maat, lev + 1)
-s.bardecos = []
 for it, x in enumerate (t):
 if x.name == 'note' or x.name == 'rest':
+if x.dur.t[0] == 0:  # a leading zero was used for stemmless in abcm2ps, we only support !stemless!
+x.dur.t = tuple ([1, x.dur.t[1]])
 note = s.mkNote (x, lev + 1)
 addElem (maat, note, lev + 1)
 elif x.name == 'lbar':
 bar = x.t[0]
-if bar == '|': pass # skip redundant bar
+if bar == '|' or bar == '[|': pass # skip redundant bar
 elif ':' in bar:    # forward repeat
 volta = x.t[1] if len (x.t) == 2  else ''
 s.mkBarline (maat, 'left', lev + 1, style='heavy-light', dir='forward', ending=volta)
 else:               # bar must be a volta number
 s.mkBarline (maat, 'left', lev + 1, ending=bar)
 elif x.name == 'rbar':
-if hasattr (x, 'deco'): # MuseScore does not support this -> emergency solution
-s.staffDecos (x.deco.t, maat, lev + 1, bardecos=1)  # coda, segno -> next measure
 bar = x.t[0]
 if bar == '.|':
 s.mkBarline (maat, 'right', lev + 1, style='dotted')
 elif ':' in bar:  # backward repeat
 s.mkBarline (maat, 'right', lev + 1, style='light-heavy', dir='backward')
 s.mkBarline (maat, 'right', lev + 1, style='none')
 elif '[' in bar or ']' in bar:
 s.mkBarline (maat, 'right', lev + 1, style='light-heavy')
 elif bar[0] == '&': overlay = 1
 elif x.name == 'tup':
-if len (x.t) == 3:  n, into, nts = x.t
+if   len (x.t) == 3: n, into, nts = x.t
-else:               n, into, nts = x.t[0], 0, 0
+elif len (x.t) == 2: n, into, nts = x.t + [0]
+else:                n, into, nts = x.t[0], 0, 0
 if into == 0: into = 3 if n in [2,4,8] else 2
 if nts == 0: nts = n
 s.tmnum, s.tmden, s.ntup = n, into, nts
 elif x.name == 'deco':
 s.staffDecos (x.t, maat, lev + 1)   # output staff decos, postpone note decos to next note
 words = E.Element ('words')
 words.text = text
 gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
 addDirection (maat, words, lev + 1, gstaff, placement=place)
 elif x.name == 'inline':
-fieldtype, fieldval = x.t[:2]
+fieldtype, fieldval = x.t[0], ' '.join (x.t[1:])
 s.doFields (maat, {fieldtype:fieldval}, lev + 1)
 elif x.name == 'accia': s.acciatura = 1
 elif x.name == 'linebrk':
 s.supports_tag = 1
 if it > 0 and t[it -1].name == 'lbar':  # we are at start of measure
 s.doChordSym (maat, x, lev + 1)
 s.stopBeams ()
 s.prevmsre = maat
 return maat, overlay
-def mkPart (s, maten, id, lev, attrs, nstaves):
+def mkPart (s, maten, id, lev, attrs, nstaves, rOpt):
-s.slurstack = []
+s.slurstack = {}
+s.glisnum = 0;          # xml number attribute for glissandos
+s.slidenum = 0;         # xml number attribute for slides
 s.unitLcur = s.unitL    # set the default unit length at begin of each voice
 s.curVolta = ''
 s.lyrdash = {}
 s.linebrk = 0
-s.midprg = ['', '']     # MIDI channel nr, program nr for the current part
+s.midprg = ['', '', '', ''] # MIDI channel nr, program nr, volume, panning for the current part
 s.gcue_on = 0           # reset cue note marker for each new voice
 s.gtrans = 0            # reset octave transposition (by clef)
+s.percVoice = 0         # 1 if percussion clef encountered
+s.curClef = ''          # current abc clef (for percmap)
+s.nostems = 0           # for the tab clef
+s.tuning = s.tuningDef  # reset string tuning to default
 part = E.Element ('part', id=id)
 s.overlayVnum = 0       # overlay voice number to relate ties that extend from one overlayed measure to the next
 gstaff = s.gStaffNums.get (s.vid, 0)    # staff number of the current voice
 attrs_cpy = attrs.copy ()   # don't change attrs itself in next line
 if gstaff == 1: attrs_cpy ['gstaff'] = nstaves  # make a grand staff
+if 'perc' in attrs_cpy.get ('V', ''): del attrs_cpy ['K'] # remove key from percussion voice
 msre, overlay = s.mkMeasure (1, maten[0], lev + 1, attrs_cpy)
 addElem (part, msre, lev + 1)
 for i, maat in enumerate (maten[1:]):
 s.overlayVnum = s.overlayVnum + 1 if overlay else 0
 msre, next_overlay = s.mkMeasure (i+2, maat, lev + 1)
-if overlay: mergePartMeasure (part, msre, s.overlayVnum)
+if overlay: mergePartMeasure (part, msre, s.overlayVnum, rOpt)
 else:       addElem (part, msre, lev + 1)
 overlay = next_overlay
 return part
 def mkScorePart (s, id, vids_p, partAttr, lev):
+def mkInst (instId, vid, midchan, midprog, midnot, vol, pan, lev):
+si = E.Element ('score-instrument', id=instId)
+pnm = partAttr.get (vid, [''])[0]   # part name if present
+addElemT (si, 'instrument-name', pnm or 'dummy', lev + 2)   # MuseScore needs a name
+mi = E.Element ('midi-instrument', id=instId)
+if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2)
+if midprog: addElemT (mi, 'midi-program', str (int (midprog) + 1), lev + 2) # compatible with abc2midi
+if midnot:  addElemT (mi, 'midi-unpitched', str (int (midnot) + 1), lev + 2)
+if vol: addElemT (mi, 'volume', '%.2f' % (int (vol) / 1.27), lev + 2)
+if pan: addElemT (mi, 'pan', '%.2f' % (int (pan) / 127. * 180 - 90), lev + 2)
+return (si, mi)
 naam, subnm, midprg = partAttr [id]
 sp = E.Element ('score-part', id='P'+id)
 nm = E.Element ('part-name')
 nm.text = naam
 addElem (sp, nm, lev + 1)
 snm = E.Element ('part-abbreviation')
 snm.text = subnm
 if subnm: addElem (sp, snm, lev + 1)    # only add if subname was given
-if s.staves: instr_vids = [vids for vids in s.staves if vids[0] == id][0]
-else:        instr_vids = [id]
 inst = []
-for id in instr_vids:
+for instId, (pid, vid, chan, midprg, vol, pan) in sorted (s.midiInst.items ()):
-if id not in partAttr: continue     # error in %%score -> instr_vids may have non existing id's
+midprg, midnot = ('0', midprg) if chan == '10' else (midprg, '')
-naam, subnm, midprg = partAttr [id]
+if pid == id: inst.append (mkInst (instId, vid, chan, midprg, midnot, vol, pan, lev))
-midchan, midprog = midprg
-if not midchan and not midprog: continue    # only add if program nr or channel was given
-si = E.Element ('score-instrument', id='I-'+id)
-addElemT (si, 'instrument-name', naam, lev + 2)
-mi = E.Element ('midi-instrument', id='I-'+id)
-if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2)
-if midprog: addElemT (mi, 'midi-program', str (int (midprog) + 1), lev + 2) # compatible with abc2midi
-inst.append ((si, mi))
 for si, mi in inst: addElem (sp, si, lev + 1)
 for si, mi in inst: addElem (sp, mi, lev + 1)
-return sp, len (inst)
+return sp
 def mkPartlist (s, vids, partAttr, lev):
 def addPartGroup (sym, num):
 pg = E.Element ('part-group', number=str (num), type='start')
 addElem (partlist, pg, lev + 1)
 addElemT (pg, 'group-symbol', sym, lev + 2)
 addElemT (pg, 'group-barline', 'yes', lev + 2)
 partlist = E.Element ('part-list')
 g_num = 0       # xml group number
-nInstrs = []    # number of instruments in each part
 for g in (s.groups or vids):    # brace/bracket or abc_voice_id
 if   g == '[': g_num += 1; addPartGroup ('bracket', g_num)
 elif g == '{': g_num += 1; addPartGroup ('brace', g_num)
 elif g in '}]':
 pg = E.Element ('part-group', number=str (g_num), type='stop')
 addElem (partlist, pg, lev + 1)
 g_num -= 1
 else:   # g = abc_voice_id
 if g not in vids: continue  # error in %%score
-sp, nInst = s.mkScorePart (g, vids, partAttr, lev + 1)
+sp = s.mkScorePart (g, vids, partAttr, lev + 1)
 addElem (partlist, sp, lev + 1)
-nInstrs.append (nInst)
+return partlist
-return partlist, nInstrs
+def doField_I (s, type, x, instDir, addTrans):
-def doField_I (s, type, x):
+def instChange (midchan, midprog):  # instDir -> doFields
+if midchan and midchan != s.midprg [0]: instDir ('midi-channel', midchan, 'chan: %s')
+if midprog and midprog != s.midprg [1]: instDir ('midi-program', str (int (midprog) + 1), 'prog: %s')
 def readPfmt (x, n): # read ABC page formatting constant
 if not s.pageFmtAbc: s.pageFmtAbc = s.pageFmtDef    # set the default values on first change
 ro = re.search (r'[^.\d]*([\d.]+)\s*(cm|in|pt)?', x)    # float followed by unit
 if ro:
 x, unit = ro.groups ()  # unit == None when not present
 u = {'cm':10., 'in':25.4, 'pt':25.4/72} [unit] if unit else 1.
 s.pageFmtAbc [n] = float (x) * u   # convert ABC values to millimeters
 else: info ('error in page format: %s' % x)
+def readPercMap (x):    # parse I:percmap <abc_note> <step> <MIDI> <notehead>
+def getMidNum (sndnm):          # find midi number of GM drum sound name
+pnms = sndnm.split ('-')    # sound name parts (from I:percmap)
+ps = s.percsnd [:]          # copy of the instruments
+_f = lambda ip, xs, pnm: ip < len (xs) and xs[ip].find (pnm) > -1   # part xs[ip] and pnm match
+for ip, pnm in enumerate (pnms):    # match all percmap sound name parts
+ps = [(nm, mnum) for nm, mnum in ps if _f (ip, nm.split ('-'), pnm) ]   # filter instruments
+if len (ps) <= 1: break # no match or one instrument left
+if len (ps) == 0: info ('drum sound: %s not found' % sndnm); return '38'
+return ps [0][1]            # midi number of (first) instrument found
+def midiVal (acc, step, oct):   # abc note -> midi note number
+oct = (4 if step.upper() == step else 5) + int (oct)
+return oct * 12 + [0,2,4,5,7,9,11]['CDEFGAB'.index (step.upper())] + {'^':1,'_':-1,'=':0}.get (acc, 0) + 12
+p0, p1, p2, p3, p4 = abc_percmap.parseString (x).asList ()  # percmap, abc-note, display-step, midi, note-head
+acc, astep, aoct = p1
+nstep, noct = (astep, aoct) if p2 == '*' else p2
+if p3 == '*':                           midi = str (midiVal (acc, astep, aoct))
+elif isinstance (p3, list_type):        midi = str (midiVal (p3[0], p3[1], p3[2]))
+elif isinstance (p3, int_type):         midi = str (p3)
+else:                                   midi = getMidNum (p3.lower ())
+head = re.sub (r'(.)-([^x])', r'\1 \2', p4) # convert abc note head names to xml
+s.percMap [(s.pid, acc + astep, aoct)] = (nstep, noct, midi, head)
 if x.startswith ('score') or x.startswith ('staves'):
 s.staveDefs += [x]          # collect all voice mappings
 elif x.startswith ('staffwidth'): info ('skipped I-field: %s' % x)
 elif x.startswith ('staff'):    # set new staff number of the current voice
 r1 = re.search (r'staff *([+-]?)(\d)', x)
 elif x.startswith ('pagewidth'): readPfmt (x, 2)
 elif x.startswith ('leftmargin'): readPfmt (x, 3)
 elif x.startswith ('rightmargin'): readPfmt (x, 4)
 elif x.startswith ('topmargin'): readPfmt (x, 5)
 elif x.startswith ('botmargin'): readPfmt (x, 6)
-elif x.startswith ('MIDI'):
+elif x.startswith ('MIDI') or x.startswith ('midi'):
 r1 = re.search (r'program *(\d*) +(\d+)', x)
-r2 = re.search (r'channel\D*(\d+)', x)
+r2 = re.search (r'channel *(\d+)', x)
-if r1: ch, prg = r1.groups ()        # channel nr or '', program nr
+r3 = re.search (r"drummap\s+([_=^]*)([A-Ga-g])([,']*)\s+(\d+)", x)
-if r2: ch, prg = r2.group (1), ''    # channel nr only
+r4 = re.search (r'control *(\d+) +(\d+)', x)
-if r1 or r2:
+ch_nw, prg_nw, vol_nw, pan_nw = '', '', '', ''
-if s.midprg[1] == '': # no instrument defined yet
+if r1: ch_nw, prg_nw = r1.groups () # channel nr or '', program nr
-s.midprg[1] = prg
+if r2: ch_nw = r2.group (1)         # channel nr only
-if ch: s.midprg[0] = ch
+if r4:
-elif ch and s.midprg[0] == '':  # no channel defined yet
+cnum, cval = r4.groups ()       # controller number, controller value
-s.midprg[0] = ch
+if cnum == '7': vol_nw = cval
-else:   # repeated midi def -> insert instument change
+if cnum == '10': pan_nw = cval
-return [ch, prg]
+if r1 or r2 or r4:
+ch  = ch_nw  or s.midprg [0]
+prg = prg_nw or s.midprg [1]
+vol = vol_nw or s.midprg [2]
+pan = pan_nw or s.midprg [3]
+instId = 'I%s-%s' % (s.pid, s.vid)              # only look for real instruments, no percussion
+if instId in s.midiInst: instChange (ch, prg)   # instChance -> doFields
+s.midprg = [ch, prg, vol, pan]  # mknote: new instrument -> s.midiInst
+if r3:      # translate drummap to percmap
+acc, step, oct, midi = r3.groups ()
+oct = -len (oct) if ',' in x else len (oct)
+notehead = 'x' if acc == '^' else 'circle-x' if acc == '_' else 'normal'
+s.percMap [(s.pid, acc + step, oct)] = (step, oct, midi, notehead)
 r = re.search (r'transpose[^-\d]*(-?\d+)', x)
-if r: return [r.group (1)]
+if r: addTrans (r.group (1))        # addTrans -> doFields
+elif x.startswith ('percmap'): readPercMap (x); s.pMapFound = 1
 else: info ('skipped I-field: %s' % x)
 def parseStaveDef (s, vdefs):
+for vid in vdefs: s.vcepid [vid] = vid              # default: each voice becomes an xml part
 if not s.staveDefs: return vdefs
 for x in s.staveDefs [1:]: info ('%%%%%s dropped, multiple stave mappings not supported' % x)
 x = s.staveDefs [0]                                 # only the first %%score is honoured
 score = abc_scoredef.parseString (x) [0]
-f = lambda x: type (x) == types.UnicodeType and [x] or x
+f = lambda x: type (x) == uni_type and [x] or x
-s.staves = map (f, mkStaves (score, vdefs))
+s.staves = lmap (f, mkStaves (score, vdefs))        # [[vid] for each staff]
-s.grands = map (f, mkGrand (score, vdefs))
+s.grands = lmap (f, mkGrand (score, vdefs))         # [staff-id], staff-id == [vid][0]
 s.groups = mkGroups (score)
 vce_groups = [vids for vids in s.staves if len (vids) > 1]  # all voice groups
 d = {}                                              # for each voice group: map first voice id -> all merged voice ids
 for vgr in vce_groups: d [vgr[0]] = vgr
 for gstaff in s.grands:                             # for all grand staves
 for v, stf_num in zip (gstaff, range (1, len (gstaff) + 1)):
 for vx in d.get (v, [v]):                   # allocate staff numbers
 s.gStaffNums [vx] = stf_num             # to all constituant voices
 s.gNstaves [vx] = len (gstaff)          # also remember total number of staves
 s.gStaffNumsOrg = s.gStaffNums.copy ()              # keep original allocation for abc -> xml staff map
+for xmlpart in s.grands:
+pid = xmlpart [0]                               # part id == first staff id == first voice id
+vces = [v for stf in xmlpart for v in d.get (stf, [stf])]
+for v in vces: s.vcepid [v] = pid
 return vdefs
 def voiceNamesAndMaps (s, ps):  # get voice names and mappings
 vdefs = {}
-for vid, vcedef, vce in ps: # vcedef == emtpy of first pObj == voice definition
+for vid, vcedef, vce in ps: # vcedef == emtpy or first pObj == voice definition
 pname, psubnm = '', ''  # part name and abbreviation
 if not vcedef:          # simple abc without voice definitions
 vdefs [vid] =  pname, psubnm, ''
 else:                   # abc with voice definitions
 if vid != vcedef.t[1]: info ('voice ids unequal: %s (reg-ex) != %s (grammar)' % (vid, vcedef.t[1]))
 rn = re.search (r'(?:name|nm)="([^"]*)"', vcedef.t[2])
 if rn: pname = rn.group (1)
 rn = re.search (r'(?:subname|snm|sname)="([^"]*)"', vcedef.t[2])
 if rn: psubnm = rn.group (1)
+vcedef.t[2] = vcedef.t[2].replace ('"%s"' % pname, '""').replace ('"%s"' % psubnm, '""')   # clear voice name to avoid false clef matches later on
 vdefs [vid] =  pname, psubnm, vcedef.t[2]
 xs = [pObj.t[1] for maat in vce for pObj in maat if pObj.name == 'inline']  # all inline statements in vce
-s.staveDefs += [x for x in xs if x.startswith ('score') or x.startswith ('staves')] # filter %%score and %%staves
+s.staveDefs += [x.replace ('%5d',']') for x in xs if x.startswith ('score') or x.startswith ('staves')] # filter %%score and %%staves
 return vdefs
 def doHeaderField (s, fld, attrmap):
-type, value = fld.t[:2]
+type, value = fld.t[0], fld.t[1].replace ('%5d',']')    # restore closing brackets (see splitHeaderVoices)
 if not value:    # skip empty field
 return
 if type == 'M':
 attrmap [type] = value
 elif type == 'L':
-try: s.unitL = map (int, fld.t[1].split ('/'))
+try: s.unitL = lmap (int, fld.t[1].split ('/'))
 except:
 info ('illegal unit length:%s, 1/8 assumed' % fld.t[1])
 s.unitL = 1,8
 if len (s.unitL) == 1 or s.unitL[1] not in s.typeMap:
 info ('L:%s is not allowed, 1/8 assumed' % fld.t[1])
 s.unitL = 1,8
 elif type == 'K':
 attrmap[type] = value
 elif type == 'T':
-if s.title: s.title = s.title + '\n' + value
+s.title = s.title + '\n' + value if s.title else value
-else:       s.title = value
-elif type == 'C':
-s.creator ['composer'] = s.creator.get ('composer', '') + value
-elif type == 'Z':
-s.creator ['lyricist'] = s.creator.get ('lyricist', '') + value
 elif type == 'U':
 sym = fld.t[2].strip ('!+')
 s.usrSyms [value] = sym
 elif type == 'I':
-s.doField_I (type, value)
+s.doField_I (type, value, lambda x,y,z:0, lambda x:0)
 elif type == 'Q':
 attrmap[type] = value
-elif type in s.creditTab: s.credits [s.creditTab [type]] = value
+elif type in 'CRZNOAGHBDFSP':           # part maps are treated as meta data
+type = s.metaMap.get (type, type)   # respect the (user defined --meta) mapping of various ABC fields to XML meta data types
+c = s.metadata.get (type, '')
+s.metadata [type] = c + '\n' + value if c else value    # concatenate multiple info fields with new line as separator
 else:
 info ('skipped header: %s' % fld)
 def mkIdentification (s, score, lev):
 if s.title:
-addElemT (score, 'movement-title', s.title, lev + 1)
+xs = s.title.split ('\n')   # the first T: line goes to work-title
+ys = '\n'.join (xs [1:])    # place subsequent T: lines into work-number
+w = E.Element ('work')
+addElem (score, w, lev + 1)
+if ys: addElemT (w, 'work-number', ys, lev + 2)
+addElemT (w, 'work-title', xs[0], lev + 2)
 ident = E.Element ('identification')
 addElem (score, ident, lev + 1)
-if s.creator:
+for mtype, mval in s.metadata.items ():
-for ctype, cname in s.creator.items ():
+if mtype in s.metaTypes and mtype != 'rights':    # all metaTypes are MusicXML creator types
-c = E.Element ('creator', type=ctype)
+c = E.Element ('creator', type=mtype)
-c.text = cname
+c.text = mval
 addElem (ident, c, lev + 2)
+if 'rights' in s.metadata:
+c = addElemT (ident, 'rights', s.metadata ['rights'], lev + 2)
 encoding = E.Element ('encoding')
 addElem (ident, encoding, lev + 2)
 encoder = E.Element ('encoder')
 encoder.text = 'abc2xml version %d' % VERSION
 addElem (encoding, encoder, lev + 3)
 suports = E.Element ('supports', attribute="new-system", element="print", type="yes", value="yes")
 addElem (encoding, suports, lev + 3)
 encodingDate = E.Element ('encoding-date')
 encodingDate.text = str (datetime.date.today ())
 addElem (encoding, encodingDate, lev + 3)
+s.addMeta (ident, lev + 2)
 def mkDefaults (s, score, lev):
 if s.pageFmtCmd: s.pageFmtAbc = s.pageFmtCmd
 if not s.pageFmtAbc: return # do not output the defaults if none is desired
-space, h, w, l, r, t, b = s.pageFmtAbc
+abcScale, h, w, l, r, t, b = s.pageFmtAbc
+space = abcScale * 2.117    # 2.117 = 6pt = space between staff lines for scale = 1.0 in abcm2ps
 mils = 4 * space    # staff height in millimeters
 scale = 40. / mils  # tenth's per millimeter
 dflts = E.Element ('defaults')
 addElem (score, dflts, lev)
 scaling = E.Element ('scaling')
 addElemT (margins, 'left-margin', '%g' % (l * scale), lev + 3)
 addElemT (margins, 'right-margin', '%g' % (r * scale), lev + 3)
 addElemT (margins, 'top-margin', '%g' % (t * scale), lev + 3)
 addElemT (margins, 'bottom-margin', '%g' % (b * scale), lev + 3)
-def mkCredits (s, score, lev):
+def addMeta (s, parent, lev):
-if not s.credits: return
+misc = E.Element ('miscellaneous')
-for ctype, ctext in s.credits.items ():
+mf = 0
-credit = E.Element ('credit', page='1')
+for mtype, mval in sorted (s.metadata.items ()):
-addElemT (credit, 'credit-type', ctype, lev + 2)
+if mtype == 'S':
-addElemT (credit, 'credit-words', ctext, lev + 2)
+addElemT (parent, 'source', mval, lev)
-addElem (score, credit, lev)
+elif mtype in s.metaTypes: continue  # mapped meta data has already been output (in creator elements)
+else:
-def parse (s, abc_string):
+mf = E.Element ('miscellaneous-field', name=s.metaTab [mtype])
-abctext = abc_string if type (abc_string) == types.UnicodeType else decodeInput (abc_string)
+mf.text = mval
-abctext = abctext.replace ('[I:staff ','[I:staff')  # avoid false beam breaks
+addElem (misc, mf, lev + 1)
-s.reset ()
+if mf != 0: addElem (parent, misc, lev)
+def parse (s, abc_string, rOpt=False, bOpt=False, fOpt=False):
+abctext = abc_string.replace ('[I:staff ','[I:staff')  # avoid false beam breaks
+s.reset (fOpt)
 header, voices = splitHeaderVoices (abctext)
 ps = []
 try:
+lbrk_insert = 0 if re.search (r'I:linebreak\s*([!$]|none)|I:continueall\s*(1|true)', header) else bOpt
 hs = abc_header.parseString (header) if header else ''
-for id, vce_lyr in voices:  # vce_lyr = [voice-block] where voice-block = (measures, corresponding lyric lines)
+for id, voice in voices:
-vcelyr = []             # list of measures where measure = list of elements (see syntax)
+if lbrk_insert:                                 # insert linebreak at EOL
+r1 = re.compile (r'\[[wA-Z]:[^]]*\]')       # inline field
+has_abc = lambda x: r1.sub ('', x).strip () # empty if line only contains inline fields
+voice = '\n'.join ([balk.rstrip ('$!') + '$' if has_abc (balk) else balk for balk in voice.splitlines ()])
 prevLeftBar = None      # previous voice ended with a left-bar symbol (double repeat)
-for voice, lyr in vce_lyr:
+s.orderChords = s.fOpt and ('tab' in voice [:200] or [x for x in hs if x.t[0] == 'K' and 'tab' in x.t[1]])
 vce = abc_voice.parseString (voice).asList ()
-if not vce:         # empty voice, insert an inline field that will be rejected
+lyr_notes = []          # remember notes between lyric blocks
-vce = [[pObj ('inline', ['I', 'empty voice'])]]
+for m in vce:           # all measures
-if prevLeftBar:
+for e in m:         # all abc-elements
-vce[0].insert (0, prevLeftBar)  # insert at begin of first measure
+if e.name == 'lyr_blk':         # -> e.objs is list of lyric lines
-prevLeftBar = None
+lyr = [line.objs for line in e.objs]    # line.objs is listof syllables
-if vce[-1] and vce[-1][-1].name == 'lbar':  # last measure ends with an lbar
+alignLyr (lyr_notes, lyr)   # put all syllables into corresponding notes
-prevLeftBar = vce[-1][-1]
+lyr_notes = []
-if len (vce) > 1:   # vce should not become empty (-> exception when taking vcelyr [0][0])
+else:
-del vce[-1]     # lbar was the only element in measure vce[-1]
+lyr_notes.append (e)
-lyr = lyr.strip ()  # strip leading \n (because we split on '\nw:...')
+if not vce:             # empty voice, insert an inline field that will be rejected
-if lyr:             # no lyrics for this measures-lyrics block
+vce = [[pObj ('inline', ['I', 'empty voice'])]]
-lyr = lyr_block.parseString (lyr).asList ()
+if prevLeftBar:
-xs = alignLyr (vce, lyr)    # put all syllables into corresponding notes
+vce[0].insert (0, prevLeftBar)  # insert at begin of first measure
-else: xs = vce
+prevLeftBar = None
-vcelyr += xs
+if vce[-1] and vce[-1][-1].name == 'lbar':  # last measure ends with an lbar
+prevLeftBar = vce[-1][-1]
+if len (vce) > 1:   # vce should not become empty (-> exception when taking vcelyr [0][0])
+del vce[-1]     # lbar was the only element in measure vce[-1]
+vcelyr = vce
 elem1 = vcelyr [0][0]   # the first element of the first measure
 if  elem1.name == 'inline'and elem1.t[0] == 'V':    # is a voice definition
 voicedef = elem1
 del vcelyr [0][0]   # do not read voicedef twice
 else:
 voicedef = ''
 ps.append ((id, voicedef, vcelyr))
-except ParseException, err:
+except ParseException as err:
 if err.loc > 40:    # limit length of error message, compatible with markInputline
 err.pstr = err.pstr [err.loc - 40: err.loc + 40]
 err.loc = 40
 xs = err.line[err.col-1:]
-try:    info (err.line.encode ('utf-8'), warn=0)    # err.line is a unicode string!!
+info (err.line, warn=0)
-except: info (err.line.encode ('latin-1'), warn=0)
 info ((err.col-1) * '-' + '^', warn=0)
-if   re.search (r'\[U:[XYZxyz]', xs):
+if   re.search (r'\[U:', xs):
 info ('Error: illegal user defined symbol: %s' % xs[1:], warn=0)
 elif re.search (r'\[[OAPZNGHRBDFSXTCIU]:', xs):
 info ('Error: header-only field %s appears after K:' % xs[1:], warn=0)
 else:
 info ('Syntax error at column %d' % err.col, warn=0)
-raise err
+raise
-s.unitL = (1, 8)
-s.title = ''
-s.creator = {}  # {creator type -> name string}
-s.credits = {}  # {credit type -> string}
 score = E.Element ('score-partwise')
 attrmap = {'Div': str (s.divisions), 'K':'C treble', 'M':'4/4'}
 for res in hs:
 if res.name == 'field':
 s.doHeaderField (res, attrmap)
 vdefs = s.voiceNamesAndMaps (ps)
 vdefs = s.parseStaveDef (vdefs)
 lev = 0
 vids, parts, partAttr = [], [], {}
+s.strAlloc = stringAlloc ()
 for vid, _, vce in ps:          # voice id, voice parse tree
 pname, psubnm, voicedef = vdefs [vid]   # part name
 attrmap ['V'] = voicedef    # abc text of first voice definition (after V:vid) or empty
 pid = 'P%s' % vid           # let part id start with an alpha
 s.vid = vid                 # avoid parameter passing, needed in mkNote for instrument id
-part = s.mkPart (vce, pid, lev + 1, attrmap, s.gNstaves.get (vid, 0))
+s.pid = s.vcepid [s.vid]    # xml part-id for the current voice
+s.gTime = (0, 0)            # reset time
+s.strAlloc.beginZoek ()     # reset search index
+part = s.mkPart (vce, pid, lev + 1, attrmap, s.gNstaves.get (vid, 0), rOpt)
 if 'Q' in attrmap: del attrmap ['Q']    # header tempo only in first part
 parts.append (part)
 vids.append (vid)
 partAttr [vid] = (pname, psubnm, s.midprg)
-parts, vidsnew = mergeParts (parts, vids, s.staves) # merge parts into staves as indicated by %%score
+if s.midprg != ['', '', '', ''] and not s.percVoice:    # when a part has only rests
-parts, _ = mergeParts (parts, vidsnew, s.grands, 1) # merge grand staves
+instId = 'I%s-%s' % (s.pid, s.vid)
+if instId not in s.midiInst: s.midiInst [instId] = (s.pid, s.vid, s.midprg [0], s.midprg [1], s.midprg [2], s.midprg [3])
+parts, vidsnew = mergeParts (parts, vids, s.staves, rOpt) # merge parts into staves as indicated by %%score
+parts, vidsnew = mergeParts (parts, vidsnew, s.grands, rOpt, 1) # merge grand staves
+reduceMids (parts, vidsnew, s.midiInst)
 s.mkIdentification (score, lev)
 s.mkDefaults (score, lev + 1)
-s.mkCredits (score, lev)
+partlist = s.mkPartlist (vids, partAttr, lev + 1)
-partlist, nInstrs = s.mkPartlist (vids, partAttr, lev + 1)
 addElem (score, partlist, lev + 1)
-for ip, part in enumerate (parts):
+for ip, part in enumerate (parts): addElem (score, part, lev + 1)
-if nInstrs [ip] < 2:    # no instrument tag needed for one- or no-instrument parts
-removeElems (part, 'measure/note', 'instrument')
-addElem (score, part, lev + 1)
 return score
 def decodeInput (data_string):
 try:        enc = 'utf-8';   unicode_string = data_string.decode (enc)
 except:
 try:    enc = 'latin-1'; unicode_string = data_string.decode (enc)
-except: raise Exception ('data not encoded in utf-8 nor in latin-1')
+except: raise ValueError ('data not encoded in utf-8 nor in latin-1')
 info ('decoded from %s' % enc)
 return unicode_string
+def ggd (a, b): # greatest common divisor
+return a if b == 0 else ggd (b, a % b)
 xmlVersion = "<?xml version='1.0' encoding='utf-8'?>"
-def fixDoctype (elem, enc):
+def fixDoctype (elem):
-xs = E.tostring (elem, encoding=enc)
+if python3: xs = E.tostring (elem, encoding='unicode')  # writing to file will auto-encode to utf-8
+else:       xs = E.tostring (elem, encoding='utf-8')    # keep the string utf-8 encoded for writing to file
 ys = xs.split ('\n')
-if enc == 'utf-8': ys.insert (0, xmlVersion)  # crooked logic of ElementTree lib
+ys.insert (0, xmlVersion)  # crooked logic of ElementTree lib
 ys.insert (1, '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 3.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">')
 return '\n'.join (ys)
 def xml2mxl (pad, fnm, data):   # write xml data to compressed .mxl file
 from zipfile import ZipFile, ZIP_DEFLATED
 f.writestr ('META-INF/container.xml', meta)
 f.writestr (fnmext, data)
 f.close ()
 info ('%s written' % outfile, warn=0)
-def convert (pad, fnm, abc_string, mxl):
+def convert (pad, fnm, abc_string, mxl, rOpt=False, tOpt=False, bOpt=False, fOpt=False):  # not used, backwards compatibility
-# these globals should be initialised (as in the __main__ secion) before calling convert
+score = mxm.parse (abc_string, rOpt, bOpt, fOpt)
-global mxm                                              # optimisation 1: keep instance of MusicXml
+writefile (pad, fnm, '', score, mxl, tOpt)
-global abc_header, abc_voice, lyr_block, abc_scoredef   # optimisation 2: keep computed grammars
-score = mxm.parse (abc_string)
+def writefile (pad, fnm, fnmNum, xmldoc, mxlOpt, tOpt=False):
+ipad, ifnm = os.path.split (fnm)                    # base name of input path is
+if tOpt:
+x = xmldoc.findtext ('work/work-title', 'no_title')
+ifnm = x.replace (',','_').replace ("'",'_').replace ('?','_')
+else:
+ifnm += fnmNum
+xmlstr = fixDoctype (xmldoc)
 if pad:
-data = fixDoctype (score, 'utf-8')
+if not mxlOpt or mxlOpt in ['a', 'add']:
-if not mxl or mxl in ['a', 'add']:
+outfnm = os.path.join (pad, ifnm + '.xml')  # joined with path from -o option
-outfnm = os.path.join (pad, fnm + '.xml')
+outfile = open (outfnm, 'w')
-outfile = file (outfnm, 'wb')
+outfile.write (xmlstr)
-outfile.write (data)
 outfile.close ()
 info ('%s written' % outfnm, warn=0)
-if mxl: xml2mxl (pad, fnm, data)     # also write a compressed version
+if mxlOpt: xml2mxl (pad, ifnm, xmlstr)          # also write a compressed version
 else:
 outfile = sys.stdout
-outfile.write (fixDoctype (score, 'utf-8'))
+outfile.write (xmlstr)
 outfile.write ('\n')
+def readfile (fnmext, errmsg='read error: '):
+try:
+if fnmext == '-.abc': fobj = stdin  # see python2/3 differences
+else: fobj = open (fnmext, 'rb')
+encoded_data = fobj.read ()
+fobj.close ()
+return encoded_data if type (encoded_data) == uni_type else decodeInput (encoded_data)
+except Exception as e:
+info (errmsg + repr (e) + ' ' + fnmext)
+return None
+def expand_abc_include (abctxt):
+ys = []
+for x in abctxt.splitlines ():
+if x.startswith ('%%abc-include') or x.startswith ('I:abc-include'):
+x = readfile (x[13:].strip (), 'include error: ')
+if x != None: ys.append (x)
+return '\n'.join (ys)
+abc_header, abc_voice, abc_scoredef, abc_percmap = abc_grammar () # compute grammars only once
+mxm = MusicXml ()               # same for instance of MusicXml
+def getXmlScores (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False): # not used, backwards compatibility
+return [fixDoctype (xml_doc) for xml_doc in
+getXmlDocs (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False)]
+def getXmlDocs (abc_string, skip=0, num=1, rOpt=False, bOpt=False, fOpt=False): # added by David Randolph
+xml_docs = []
+abctext = expand_abc_include (abc_string)
+fragments = re.split ('^\s*X:', abctext, flags=re.M)
+preamble = fragments [0]    # tunes can be preceeded by formatting instructions
+tunes = fragments[1:]
+if not tunes and preamble: tunes, preamble = ['1\n' + preamble], ''  # tune without X:
+for itune, tune in enumerate (tunes):
+if itune < skip: continue           # skip tunes, then read at most num tunes
+if itune >= skip + num: break
+tune = preamble + 'X:' + tune       # restore preamble before each tune
+try:                                # convert string abctext -> file pad/fnmNum.xml
+score = mxm.parse (tune, rOpt, bOpt, fOpt)
+ds = list (score.iter ('duration')) # need to iterate twice
+ss = [int (d.text) for d in ds]
+deler = reduce (ggd, ss + [21]) # greatest common divisor of all durations
+for i, d in enumerate (ds): d.text = str (ss [i] // deler)
+for d in score.iter ('divisions'): d.text = str (int (d.text) // deler)
+xml_docs.append (score)
+except ParseException:
+pass         # output already printed
+except Exception as err:
+info ('an exception occurred.\n%s' % err)
+return xml_docs
 #----------------
 # Main Program
 #----------------
 if __name__ == '__main__':
 from optparse import OptionParser
 from glob import glob
 import time
-global mxm      # keep instance of MusicXml
-global abc_header, abc_voice, lyr_block, abc_scoredef # keep computed grammars
+parser = OptionParser (usage='%prog [-h] [-r] [-t] [-b] [-m SKIP NUM] [-o DIR] [-p PFMT] [-z MODE] [--meta MAP] <file1> [<file2> ...]', version='version %d' % VERSION)
-mxm = MusicXml ()
-parser = OptionParser (usage='%prog [-h] [-r] [-m SKIP NUM] [-o DIR] [-p PFMT] [-z MODE] <file1> [<file2> ...]', version='version %d' % VERSION)
 parser.add_option ("-o", action="store", help="store xml files in DIR", default='', metavar='DIR')
-parser.add_option ("-m", action="store", help="skip SKIP tunes, then read at most NUM tunes", nargs=2, type='int', default=(0,1), metavar='SKIP NUM')
+parser.add_option ("-m", action="store", help="skip SKIP (0) tunes, then read at most NUM (1) tunes", nargs=2, type='int', default=(0,1), metavar='SKIP NUM')
-parser.add_option ("-p", action="store", help="page formatting in PFMT", default='', metavar='PFMT')
+parser.add_option ("-p", action="store", help="pageformat PFMT (mm) = scale (0.75), pageheight (297), pagewidth (210), leftmargin (18), rightmargin (18), topmargin (10), botmargin (10)", default='', metavar='PFMT')
 parser.add_option ("-z", "--mxl", dest="mxl", help="store as compressed mxl, MODE = a(dd) or r(eplace)", default='', metavar='MODE')
 parser.add_option ("-r", action="store_true", help="show whole measure rests in merged staffs", default=False)
+parser.add_option ("-t", action="store_true", help="use tune title as file name", default=False)
+parser.add_option ("-b", action="store_true", help="line break at EOL", default=False)
+parser.add_option ("--meta", action="store", help="map infofields to XML metadata, MAP = R:poet,Z:lyricist,N:...", default='', metavar='MAP')
+parser.add_option ("-f", action="store_true", help="force string/fret allocations for tab staves", default=False)
 options, args = parser.parse_args ()
 if len (args) == 0: parser.error ('no input file given')
 pad = options.o
 if options.mxl and options.mxl not in ['a','add', 'r', 'replace']:
 parser.error ('MODE should be a(dd) or r(eplace), not: %s' % options.mxl)
 if pad:
 if not os.path.exists (pad): os.mkdir (pad)
 if not os.path.isdir (pad): parser.error ('%s is not a directory' % pad)
 if options.p:   # set page formatting values
 try:        # space, page-height, -width, margin-left, -right, -top, -bottom
-mxm.pageFmtCmd = map (float, options.p.split (','))
+mxm.pageFmtCmd = lmap (float, options.p.split (','))
-if len (mxm.pageFmtCmd) != 7: raise Exception ('-p needs 7 values')
+if len (mxm.pageFmtCmd) != 7: raise ValueError ('-p needs 7 values')
-except Exception, err: parser.error (err)
+except Exception as err: parser.error (err)
-mxm.gmwr = options.r    # ugly: needs to be globally accessable
+for x in options.meta.split (','):
+if not x: continue
-abc_header, abc_voice, lyr_block, abc_scoredef = abc_grammar ()  # compute grammar only once per file set
+try: field, tag = x.split (':')
+except: parser.error ('--meta: %s cannot be split on colon' % x)
+if field not in 'OAZNGHRBDFSPW': parser.error ('--meta: field %s is no valid ABC field' % field)
+if tag not in mxm.metaTypes: parser.error ('--meta: tag %s is no valid XML creator type' % tag)
+mxm.metaMap [field] = tag
 fnmext_list = []
-for i in args: fnmext_list += glob (i)
+for i in args:
+if i == '-': fnmext_list.append ('-.abc')   # represents standard input
+else:        fnmext_list += glob (i)
 if not fnmext_list: parser.error ('none of the input files exist')
 t_start = time.time ()
-for X, fnmext in enumerate (fnmext_list):
+for fnmext in fnmext_list:
 fnm, ext = os.path.splitext (fnmext)
 if ext.lower () not in ('.abc'):
 info ('skipped input file %s, it should have extension .abc' % fnmext)
 continue
 if os.path.isdir (fnmext):
 info ('skipped directory %s. Only files are accepted' % fnmext)
 continue
+abctext = readfile (fnmext)
-fobj = open (fnmext, 'rb')
+skip, num = options.m
-encoded_data = fobj.read ()
+xml_docs = getXmlDocs (abctext, skip, num, options.r, options.b, options.f)
-fobj.close ()
+for itune, xmldoc in enumerate (xml_docs):
-fragments =  encoded_data.split ('X:')
+fnmNum = '%02d' % (itune + 1) if len (xml_docs) > 1 else ''
-preamble = fragments [0]    # tunes can be preceeded by formatting instructions
+writefile (pad, fnm, fnmNum, xmldoc, options.mxl, options.t)
-tunes = fragments[1:]
-if not tunes and preamble: tunes, preamble = ['1\n' + preamble], ''  # tune without X:
-skip, num = options.m       # skip tunes, then read at most num tunes
-numtunes = min ([len (tunes), num])     # number of tunes to be converted
-for itune, tune in enumerate (tunes):
-if itune < skip: continue
-if itune >= skip + num: break
-tune = preamble + 'X:' + tune       # restore preamble before each tune
-fnmNum = '%s%02d' % (fnm, itune + 1) if numtunes > 1 else fnm
-try:                                # convert string abctext -> file pad/fnmNum.xml
-convert (pad, fnmNum, tune, options.mxl)
-except ParseException, err: pass    # output already printed
-except Exception, err: info ('an exception occurred.\n%s' % err)
 info ('done in %.2f secs' % (time.time () - t_start))

Mercurial > dottes

comparison abc2xml/abc2xml.py @ 1084:b1dbb76f4eb9 build-default-404