# -*- coding: utf-8 -*-
# (setq py-indent-offset 4)
#
# This file is part of LilyPond, the GNU music typesetter.
#
# Copyright (C) 1998--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>,
#                          Jan Nieuwenhuizen <janneke@gnu.org>
#
# LilyPond 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 3 of the License, or
# (at your option) any later version.
#
# LilyPond is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.


import re
import string
import sys

import lilylib


NOT_SMART = "\n" + _("Not smart enough to convert %s.") + "\n"
UPDATE_MANUALLY = _(
    "Please refer to the manual for details, and update manually.") + "\n"
FROM_TO = _("%s has been replaced by %s") + "\n"


class FatalConversionError(Exception):
    pass


conversions = []
stderr_write = sys.stderr.write


def warning(s):
    stderr_write(_("warning: %s") % s)

# Decorator to make rule syntax simpler


def rule(version, message):
    """
    version: a LilyPond version tuple like (2, 11, 50)
    message: the message that describes the conversion.

    This decorator adds its function together with the version and the
    message to the global conversions list.  (It doesn't need to return
    the function as it isn't used directly anyway.)

    A conversion rule using this decorator looks like this:

    @rule ((1, 2, 3), "convert foo to bar")
    def conv(s):
        s = s.replace('foo', 'bar')
        return s

    """
    def dec(f):
        conversions.append((version, f, message))
    return dec


@rule((0, 1, 9), _('\\header { key = concat + with + operator }'))
def conv(s):
    if re.search('\\\\multi', s):
        stderr_write(NOT_SMART % "\\multi")
    return s


@rule((0, 1, 19), _('deprecated %s') % '\\octave')
def conv(s):
    if re.search('\\\\octave', s):
        stderr_write(NOT_SMART % "\\octave")
        stderr_write(UPDATE_MANUALLY)
    #   raise FatalConversionError ()
    return s


@rule((0, 1, 20), _('deprecated \\textstyle, new \\key syntax'))
def conv(s):
    s = re.sub('\\\\textstyle([^;]+);',
                 '\\\\property Lyrics . textstyle = \\1', s)
    # harmful to current .lys
    # s = re.sub ('\\\\key([^;]+);', '\\\\accidentals \\1;', s)
    return s


@rule((0, 1, 21), '\\musical_pitch -> \\musicalpitch, \\meter -> \\time')
def conv(s):
    s = re.sub('\\\\musical_pitch', '\\\\musicalpitch', s)
    s = re.sub('\\\\meter', '\\\\time', s)
    return s


@rule((1, 0, 0), _("bump version for release"))
def conv(s):
    return s


@rule((1, 0, 1), '\\accidentals -> \\keysignature, specialaccidentals -> keyoctaviation')
def conv(s):
    s = re.sub('\\\\accidentals', '\\\\keysignature', s)
    s = re.sub('specialaccidentals *= *1', 'keyoctaviation = 0', s)
    s = re.sub('specialaccidentals *= *0', 'keyoctaviation = 1', s)
    return s


@rule((1, 0, 2), _('\\header { key = concat + with + operator }'))
def conv(s):
    if re.search('\\\\header', s):
        stderr_write(NOT_SMART % _("new \\header format"))
    return s


@rule((1, 0, 3), '\\melodic -> \\notes')
def conv(s):
    s = re.sub('\\\\melodic([^a-zA-Z])', '\\\\notes\\1', s)
    return s


@rule((1, 0, 4), 'default_{paper,midi}')
def conv(s):
    s = re.sub('default_paper *=', '', s)
    s = re.sub('default_midi *=', '', s)
    return s


@rule((1, 0, 5), 'ChoireStaff -> ChoirStaff')
def conv(s):
    s = re.sub('ChoireStaff', 'ChoirStaff', s)
    s = re.sub('\\\\output', 'output = ', s)
    return s


@rule((1, 0, 6), 'foo = \\translator {\\type .. } ->\\translator {\\type ..; foo; }')
def conv(s):
    if re.search('[a-zA-Z]+ = *\\translator', s):
        stderr_write(NOT_SMART % _("\\translator syntax"))
    #   raise FatalConversionError ()
    return s


@rule((1, 0, 7), '\\lyric -> \\lyrics')
def conv(s):
    s = re.sub('\\\\lyrics*', '\\\\lyrics', s)
    return s


@rule((1, 0, 10), '[2/3 ]1/1 -> \\times 2/3 ')
def conv(s):
    s = re.sub('\\\\\\[/3+', '\\\\times 2/3 { ', s)
    s = re.sub('\\[/3+', '\\\\times 2/3 { [', s)
    s = re.sub('\\\\\\[([0-9/]+)', '\\\\times \\1 {', s)
    s = re.sub('\\[([0-9/]+)', '\\\\times \\1 { [', s)
    s = re.sub('\\\\\\]([0-9/]+)', '}', s)
    s = re.sub('\\\\\\]', '}', s)
    s = re.sub('\\]([0-9/]+)', '] }', s)
    return s


@rule((1, 0, 12), 'Chord syntax stuff')
def conv(s):
    return s


@rule((1, 0, 13), '<a ~ b> c -> <a b> ~ c')
def conv(s):
    s = re.sub('<([^>~]+)~([^>]*)>', '<\\1 \\2> ~', s)
    return s


@rule((1, 0, 14), '<[a b> <a b]>c -> [<a b> <a b>]')
def conv(s):
    s = re.sub('<\\[', '[<', s)
    s = re.sub('\\]>', '>]', s)
    return s


@rule((1, 0, 16), '\\type -> \\context, textstyle -> textStyle')
def conv(s):
    s = re.sub('\\\\type([^\n]*engraver)', '\\\\TYPE\\1', s)
    s = re.sub('\\\\type([^\n]*performer)', '\\\\TYPE\\1', s)
    s = re.sub('\\\\type', '\\\\context', s)
    s = re.sub('\\\\TYPE', '\\\\type', s)
    s = re.sub('textstyle', 'textStyle', s)
    return s


@rule((1, 0, 18), _('\\repeat NUM Music Alternative -> \\repeat FOLDSTR Music Alternative'))
def conv(s):
    if re.search('\\\\repeat', s):
        stderr_write(NOT_SMART % "\\repeat")
    #   raise FatalConversionError ()
    return s


@rule((1, 0, 19), 'fontsize -> fontSize, midi_instrument -> midiInstrument, SkipBars -> skipBars')
def conv(s):
    s = re.sub('SkipBars', 'skipBars', s)
    s = re.sub('fontsize', 'fontSize', s)
    s = re.sub('midi_instrument', 'midiInstrument', s)
    return s


@rule((1, 0, 20), '{,tie,slur}ydirection -> {v,tieV,slurV}erticalDirection')
def conv(s):
    s = re.sub('tieydirection', 'tieVerticalDirection', s)
    s = re.sub('slurydirection', 'slurVerticalDirection', s)
    s = re.sub('ydirection', 'verticalDirection', s)
    return s


@rule((1, 0, 21), 'hshift -> horizontalNoteShift')
def conv(s):
    s = re.sub('hshift', 'horizontalNoteShift', s)
    return s


@rule((1, 1, 52), _('deprecate %s') % '\\grouping')
def conv(s):
    s = re.sub('\\\\grouping[^;]*;', '', s)
    return s


@rule((1, 1, 55), '\\wheel -> \\coda')
def conv(s):
    s = re.sub('\\\\wheel', '\\\\coda', s)
    return s


@rule((1, 1, 65), 'slurdash -> slurDash, keyoctaviation -> keyOctaviation')
def conv(s):
    s = re.sub('keyoctaviation', 'keyOctaviation', s)
    s = re.sub('slurdash', 'slurDash', s)
    return s


@rule((1, 1, 66), 'semi -> volta')
def conv(s):
    s = re.sub('\\\\repeat *"?semi"?', '\\\\repeat "volta"', s)
    return s


@rule((1, 1, 67), 'beamAuto -> noAutoBeaming')
def conv(s):
    s = re.sub('"?beamAuto"? *= *"?0?"?', 'noAutoBeaming = "1"', s)
    return s


@rule((1, 2, 0), 'automaticMelismas -> automaticMelismata')
def conv(s):
    s = re.sub('automaticMelismas', 'automaticMelismata', s)
    return s


@rule((1, 2, 1), 'dynamicDir -> dynamicDirection')
def conv(s):
    s = re.sub('dynamicDir\\b', 'dynamicDirection', s)
    return s


@rule((1, 3, 4), '\\cadenza -> \\cadenza{On|Off}')
def conv(s):
    s = re.sub('\\\\cadenza *0 *;', '\\\\cadenzaOff', s)
    s = re.sub('\\\\cadenza *1 *;', '\\\\cadenzaOn', s)
    return s


@rule((1, 3, 5), 'beamAuto moment properties')
def conv(s):
    s = re.sub('"?beamAuto([^"=]+)"? *= *"([0-9]+)/([0-9]+)" *;*',
                 'beamAuto\\1 = #(make-moment \\2 \\3)',
                 s)
    return s


@rule((1, 3, 17), 'stemStyle -> flagStyle')
def conv(s):
    s = re.sub('stemStyle',
                 'flagStyle',
                 s)
    return s


@rule((1, 3, 18), 'staffLineLeading -> staffSpace')
def conv(s):
    s = re.sub('staffLineLeading',
                 'staffSpace',
                 s)
    return s


@rule((1, 3, 23), _('deprecate %s ') % '\\repetitions')
def conv(s):
    if re.search('\\\\repetitions', s):
        stderr_write(NOT_SMART % "\\repetitions")
    #   raise FatalConversionError ()
    return s


@rule((1, 3, 35), 'textEmptyDimension -> textNonEmpty')
def conv(s):
    s = re.sub('textEmptyDimension *= *##t',
                 'textNonEmpty = ##f',
                 s)
    s = re.sub('textEmptyDimension *= *##f',
                 'textNonEmpty = ##t',
                 s)
    return s


@rule((1, 3, 38), r"\musicalpitch { a b c } -> #'(a b c)")
def conv(s):
    s = re.sub("([a-z]+)[ \t]*=[ \t]*\\\\musicalpitch *{([- 0-9]+)} *\n",
                 "(\\1 . (\\2))\n", s)
    s = re.sub("\\\\musicalpitch *{([0-9 -]+)}",
                 "\\\\musicalpitch #'(\\1)", s)
    if re.search('\\\\notenames', s):
        stderr_write(NOT_SMART % _("new \\notenames format"))
    return s


@rule((1, 3, 39), '\\key A ;  ->\\key a;')
def conv(s):
    def replace(match):
        return '\\key %s;' % match.group(1).lower()

    s = re.sub("\\\\key ([^;]+);",  replace, s)
    return s


@rule((1, 3, 41), '[:16 c4 d4 ] -> \\repeat "tremolo" 2 { c16 d16 }')
def conv(s):
    if re.search('\\[:', s):
        stderr_write(NOT_SMART % _("new tremolo format"))
    return s


@rule((1, 3, 42), _('Staff_margin_engraver deprecated, use Instrument_name_engraver'))
def conv(s):
    s = re.sub('Staff_margin_engraver', 'Instrument_name_engraver', s)
    return s


@rule((1, 3, 49), 'noteHeadStyle value: string -> symbol')
def conv(s):
    s = re.sub('note[hH]eadStyle\\s*=\\s*"?(\\w+)"?',
                 "noteHeadStyle = #'\\1", s)
    return s


@rule((1, 3, 58), 'noteHeadStyle value: string -> symbol')
def conv(s):
    if re.search('\\\\keysignature', s):
        stderr_write(NOT_SMART % '\\keysignature')
    return s


@rule((1, 3, 59), r'\key X ; -> \key X major; ')
def conv(s):
    s = re.sub(r"""\\key *([a-z]+) *;""", r"""\\key \1 \\major;""", s)
    return s


@rule((1, 3, 68), 'latexheaders = "\\input global" -> latexheaders = "global"')
def conv(s):
    s = re.sub(r'latexheaders *= *"\\\\input ',
                 'latexheaders = "',
                 s)
    return s


# TODO: lots of other syntax changes should be done here as well
@rule((1, 3, 92), 'basicXXXProperties -> XXX, Repeat_engraver -> Volta_engraver')
def conv(s):
    s = re.sub('basicCollisionProperties', 'NoteCollision', s)
    s = re.sub('basicVoltaSpannerProperties', "VoltaBracket", s)
    s = re.sub('basicKeyProperties', "KeySignature", s)

    s = re.sub('basicClefItemProperties', "Clef", s)

    s = re.sub('basicLocalKeyProperties', "Accidentals", s)
    s = re.sub('basicMarkProperties', "Accidentals", s)
    s = re.sub('basic([A-Za-z_]+)Properties', '\\1', s)

    s = re.sub('Repeat_engraver', 'Volta_engraver', s)
    return s


@rule((1, 3, 93), _('change property definition case (eg. onevoice -> oneVoice)'))
def conv(s):
    # Ugh, but meaning of \stemup changed too
    # maybe we should do \stemup -> \stemUp\slurUp\tieUp ?
    s = re.sub('\\\\stemup', '\\\\stemUp', s)
    s = re.sub('\\\\stemdown', '\\\\stemDown', s)
    s = re.sub('\\\\stemboth', '\\\\stemBoth', s)

    s = re.sub('\\\\slurup', '\\\\slurUp', s)
    s = re.sub('\\\\slurboth', '\\\\slurBoth', s)
    s = re.sub('\\\\slurdown', '\\\\slurDown', s)
    s = re.sub('\\\\slurdotted', '\\\\slurDotted', s)
    s = re.sub('\\\\slurnormal', '\\\\slurNoDots', s)

    s = re.sub('\\\\shiftoff', '\\\\shiftOff', s)
    s = re.sub('\\\\shifton', '\\\\shiftOn', s)
    s = re.sub('\\\\shiftonn', '\\\\shiftOnn', s)
    s = re.sub('\\\\shiftonnn', '\\\\shiftOnnn', s)

    s = re.sub('\\\\onevoice', '\\\\oneVoice', s)
    s = re.sub('\\\\voiceone', '\\\\voiceOne', s)
    s = re.sub('\\\\voicetwo', '\\\\voiceTwo', s)
    s = re.sub('\\\\voicethree', '\\\\voiceThree', s)
    s = re.sub('\\\\voicefour', '\\\\voiceFour', s)

    # I don't know exactly when these happened...
    # ugh, we lose context setting here...
    s = re.sub('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?(1|(\\\\up))"?',
                 '\\\\stemUp\\\\slurUp\\\\tieUp', s)
    s = re.sub('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?',
                 '\\\\stemDown\\\\slurDown\\\\tieDown', s)
    s = re.sub('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?(0|(\\\\center))"?',
                 '\\\\stemBoth\\\\slurBoth\\\\tieBoth', s)

    s = re.sub('verticalDirection[^=]*= *#?"?(1|(\\\\up))"?',
                 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #1', s)
    s = re.sub('verticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?',
                 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #-1', s)
    s = re.sub('verticalDirection[^=]*= *#?"?(0|(\\\\center))"?',
                 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #0', s)

    s = re.sub(
        '\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\\\\\1Up', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?', '\\\\\\1Down', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?(0|(\\\\center))"?', '\\\\\\1Both', s)

    # (lacks capitalization slur -> Slur)
    s = re.sub('([a-z]+)VerticalDirection[^=]*= *#?"?(1|(\\\\up))"?',
                 '\\1 \\\\override #\'direction = #1', s)
    s = re.sub('([a-z]+)VerticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?',
                 '\\1 \\\\override #\'direction = #-1', s)
    s = re.sub('([a-z]+)VerticalDirection[^=]*= *#?"?(0|(\\\\center))"?',
                 '\\1 \\\\override #\'direction = #0', s)

    # dynamic..
    s = re.sub(
        '\\\\property *[^ .]*[.]?dynamicDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\\\dynamicUp', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?dyn[^=]*= *#?"?((-1)|(\\\\down))"?', '\\\\dynamicDown', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?dyn[^=]*= *#?"?(0|(\\\\center))"?', '\\\\dynamicBoth', s)

    s = re.sub(
        '\\\\property *[^ .]*[.]?([a-z]+)Dash[^=]*= *#?"?(0|(""))"?', '\\\\\\1NoDots', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?([a-z]+)Dash[^=]*= *#?"?([1-9]+)"?', '\\\\\\1Dotted', s)

    s = re.sub(
        '\\\\property *[^ .]*[.]?noAutoBeaming[^=]*= *#?"?(0|(""))"?', '\\\\autoBeamOn', s)
    s = re.sub(
        '\\\\property *[^ .]*[.]?noAutoBeaming[^=]*= *#?"?([1-9]+)"?', '\\\\autoBeamOff', s)
    return s


@rule((1, 3, 97), 'ChordName -> ChordNames')
def conv(s):
    s = re.sub('ChordNames*', 'ChordNames', s)
    if re.search('\\\\textscript "[^"]* *"[^"]*"', s):
        stderr_write(NOT_SMART % _("new \\textscript markup text"))

    s = re.sub('\\textscript +("[^"]*")', '\\textscript #\\1', s)
    return s

# TODO: add lots of these


@rule((1, 3, 98), 'CONTEXT.textStyle -> GROB.#font-style ')
def conv(s):
    s = re.sub('\\\\property *"?Voice"? *[.] *"?textStyle"? *= *"([^"]*)"',
                 '\\\\property Voice.TextScript \\\\set #\'font-style = #\'\\1', s)
    s = re.sub('\\\\property *"?Lyrics"? *[.] *"?textStyle"? *= *"([^"]*)"',
                 '\\\\property Lyrics.LyricText \\\\set #\'font-style = #\'\\1', s)

    s = re.sub('\\\\property *"?([^.]+)"? *[.] *"?timeSignatureStyle"? *= *"([^"]*)"',
                 '\\\\property \\1.TimeSignature \\\\override #\'style = #\'\\2', s)

    s = re.sub('"?timeSignatureStyle"? *= *#?""',
                 'TimeSignature \\\\override #\'style = ##f', s)

    s = re.sub('"?timeSignatureStyle"? *= *#?"([^"]*)"',
                 'TimeSignature \\\\override #\'style = #\'\\1', s)

    s = re.sub('#\'style *= #*"([^"])"', '#\'style = #\'\\1', s)

    s = re.sub('\\\\property *"?([^.]+)"? *[.] *"?horizontalNoteShift"? *= *"?#?([-0-9]+)"?',
                 '\\\\property \\1.NoteColumn \\\\override #\'horizontal-shift = #\\2', s)

    # ugh
    s = re.sub('\\\\property *"?([^.]+)"? *[.] *"?flagStyle"? *= *""',
                 '\\\\property \\1.Stem \\\\override #\'flag-style = ##f', s)

    s = re.sub('\\\\property *"?([^.]+)"? *[.] *"?flagStyle"? *= *"([^"]*)"',
                 '\\\\property \\1.Stem \\\\override #\'flag-style = #\'\\2', s)
    return s


@rule((1, 3, 102), 'beamAutoEnd -> autoBeamSettings \\push (end * * * *)')
def conv(s):
    s = re.sub('"?beamAutoEnd_([0-9]*)"? *= *(#\\([^)]*\\))',
                 'autoBeamSettings \\\\push #\'(end 1 \\1 * *) = \\2', s)
    s = re.sub('"?beamAutoBegin_([0-9]*)"? *= *(#\\([^)]*\\))',
                 'autoBeamSettings \\\\push #\'(begin 1 \\1 * *) = \\2', s)
    s = re.sub('"?beamAutoEnd"? *= *(#\\([^)]*\\))',
                 'autoBeamSettings \\\\push #\'(end * * * *) = \\1', s)
    s = re.sub('"?beamAutoBegin"? *= *(#\\([^)]*\\))',
                 'autoBeamSettings \\\\push #\'(begin * * * *) = \\1', s)
    return s


@rule((1, 3, 111), '\\push -> \\override, \\pop -> \\revert')
def conv(s):
    s = re.sub('\\\\push', '\\\\override', s)
    s = re.sub('\\\\pop', '\\\\revert', s)
    return s


@rule((1, 3, 113), 'LyricVoice -> LyricsVoice')
def conv(s):
    s = re.sub('LyricVoice', 'LyricsVoice', s)
    # old fix
    s = re.sub('Chord[Nn]ames*.Chord[Nn]ames*', 'ChordNames.ChordName', s)
    s = re.sub('Chord[Nn]ames([ \t\n]+\\\\override)', 'ChordName\\1', s)
    return s


def regularize_id(s):
    s = ''
    lastx = ''
    for x in s:
        if x == '_':
            lastx = x
            continue
        elif x in string.digits:
            x = chr(ord(x) - ord('0') + ord('A'))
        elif x not in string.letters:
            x = 'x'
        elif x in string.lowercase and lastx == '_':
            x = x.upper()
        s = s + x
        lastx = x
    return s


@rule((1, 3, 117), _('identifier names: %s') % '$!foo_bar_123 -> xfooBarABC')
def conv(s):
    def regularize_dollar_reference(match):
        return regularize_id(match.group(1))

    def regularize_assignment(match):
        return '\n' + regularize_id(match.group(1)) + ' = '
    s = re.sub(r'\$([^\t\n ]+)', regularize_dollar_reference, s)
    s = re.sub('\n([^ \t\n]+)[ \t]*= *', regularize_assignment, s)
    return s


@rule((1, 3, 120), 'paper_xxx -> paperXxxx, pedalup -> pedalUp.')
def conv(s):
    def regularize_paper(match):
        return regularize_id(match.group(1))
    s = re.sub('(paper_[a-z]+)', regularize_paper, s)
    s = re.sub('sustainup', 'sustainUp', s)
    s = re.sub('nobreak', 'noBreak', s)
    s = re.sub('sustaindown', 'sustainDown', s)
    s = re.sub('sostenutoup', 'sostenutoUp', s)
    s = re.sub('sostenutodown', 'sostenutoDown', s)
    s = re.sub('unachorda', 'unaChorda', s)
    s = re.sub('trechorde', 'treChorde', s)
    return s


@rule((1, 3, 122), 'drarnChords -> chordChanges, \\musicalpitch -> \\pitch')
def conv(s):
    s = re.sub('drarnChords', 'chordChanges', s)
    s = re.sub(r'\\musicalpitch', r'\\pitch', s)
    return s


@rule((1, 3, 136), 'ly-X-elt-property -> ly-X-grob-property')
def conv(s):
    s = re.sub('ly-([sg])et-elt-property', 'ly-\\1et-grob-property', s)
    return s


@rule((1, 3, 138), _('point-and-click argument changed to procedure.'))
def conv(s):
    s = re.sub('point-and-click +#t',
                 'point-and-click line-column-location', s)
    return s


@rule((1, 3, 138), 'followThread -> followVoice.')
def conv(s):
    s = re.sub('followThread', 'followVoice', s)
    s = re.sub('Thread.FollowThread', 'Voice.VoiceFollower', s)
    s = re.sub('FollowThread', 'VoiceFollower', s)
    return s


@rule((1, 3, 139), 'font-point-size -> font-design-size.')
def conv(s):
    s = re.sub('font-point-size', 'font-design-size', s)
    return s


@rule((1, 3, 141), 'xNoDots -> xSolid')
def conv(s):
    s = re.sub('([a-zA-Z]*)NoDots', '\\1Solid', s)
    return s


@rule((1, 3, 144), 'Chorda -> Corda')
def conv(s):
    s = re.sub('([Cc])hord([ea])', '\\1ord\\2', s)
    return s


@rule((1, 3, 145), 'ContextNameXxxxVerticalExtent -> XxxxVerticalExtent')
def conv(s):
    s = re.sub('([A-Za-z]+)MinimumVerticalExtent',
                 'MinimumV@rticalExtent', s)
    s = re.sub('([A-Za-z]+)ExtraVerticalExtent', 'ExtraV@rticalExtent', s)
    s = re.sub('([A-Za-z]+)VerticalExtent', 'VerticalExtent', s)
    s = re.sub('ExtraV@rticalExtent', 'ExtraVerticalExtent', s)
    s = re.sub('MinimumV@rticalExtent', 'MinimumVerticalExtent', s)
    return s


@rule((1, 3, 146), _('semicolons removed'))
def conv(s):
    s = re.sub('\\\\key[ \t]*;', r'\\key \\default;', s)
    s = re.sub('\\\\mark[ \t]*;', r'\\mark \\default;', s)

    # Make sure groups of more than one ; have space before
    # them, so that non of them gets removed by next rule
    s = re.sub("([^ \n\t;]);(;+)", "\\1 ;\\2", s)

    # Only remove ; that are not after spaces, # or ;
    # Otherwise  we interfere with Scheme comments,
    # which is badbadbad.
    s = re.sub("([^ \t;#]);", "\\1", s)
    return s


@rule((1, 3, 147), 'default-neutral-direction -> neutral-direction')
def conv(s):
    s = re.sub('default-neutral-direction', 'neutral-direction', s)
    return s


@rule((1, 3, 148), '"(align" -> "(axis", "(rows" -> "(columns"')
def conv(s):
    s = re.sub(r'\(align', '(axis', s)
    s = re.sub(r'\(rows', '(columns', s)
    return s


@rule((1, 5, 33), 'SystemStartDelimiter -> systemStartDelimiter')
def conv(s):
    s = re.sub('SystemStartDelimiter', 'systemStartDelimiter', s)
    return s


@rule((1, 5, 38), 'arithmetic... -> spacing...')
def conv(s):
    s = re.sub('arithmetic-multiplier', 'spacing-increment', s)
    s = re.sub('arithmetic-basicspace', 'shortest-duration-space', s)
    return s


# 40 ?
@rule((1, 5, 40), _('%s property names') % 'breakAlignOrder')
def conv(s):

    def func(match):
        break_dict = {
            "Instrument_name": "instrument-name",
            "Left_edge_item": "left-edge",
            "Span_bar": "span-bar",
            "Breathing_sign": "breathing-sign",
            "Staff_bar": "staff-bar",
            "Clef_item": "clef",
            "Key_item": "key-signature",
            "Time_signature": "time-signature",
            "Custos": "custos"
        }
        props = match.group(1)
        for (k, v) in list(break_dict.items()):
            props = re.sub(k, v, props)
        return "breakAlignOrder = #'(%s)" % props

    s = re.sub("breakAlignOrder *= *#'\\(([a-z_\n\tA-Z ]+)\\)",
                 func, s)
    return s


@rule((1, 5, 49), 'noAutoBeaming -> autoBeaming')
def conv(s):
    s = re.sub('noAutoBeaming *= *##f', 'autoBeaming = ##t', s)
    s = re.sub('noAutoBeaming *= *##t', 'autoBeaming = ##f', s)
    return s


@rule((1, 5, 52), 'tuplet-X-visibility -> X-visibility')
def conv(s):
    s = re.sub('tuplet-bracket-visibility', 'bracket-visibility', s)
    s = re.sub('tuplet-number-visibility', 'number-visibility', s)
    return s


@rule((1, 5, 56), 'Pitch::transpose -> ly-transpose-pitch')
def conv(s):
    s = re.sub('Pitch::transpose', 'ly-transpose-pitch', s)
    return s


@rule((1, 5, 58), _('deprecate %s') % 'textNonEmpty')
def conv(s):
    s = re.sub('textNonEmpty *= *##t',
                 "TextScript \\\\set #'no-spacing-rods = ##f", s)
    s = re.sub('textNonEmpty *= *##f',
                 "TextScript \\\\set #'no-spacing-rods = ##t", s)
    return s


@rule((1, 5, 59), 'XxxxVerticalExtent -> xxxVerticalExtent')
def conv(s):
    s = re.sub('MinimumVerticalExtent', 'minimumV@rticalExtent', s)
    s = re.sub('minimumVerticalExtent', 'minimumV@rticalExtent', s)
    s = re.sub('ExtraVerticalExtent', 'extraV@rticalExtent', s)
    s = re.sub('extraVerticalExtent', 'extraV@rticalExtent', s)
    s = re.sub('VerticalExtent', 'verticalExtent', s)
    s = re.sub('extraV@rticalExtent', 'extraVerticalExtent', s)
    s = re.sub('minimumV@rticalExtent', 'minimumVerticalExtent', s)
    return s


@rule((1, 5, 62), 'visibility-lambda -> break-visibility')
def conv(s):
    s = re.sub('visibility-lambda', 'break-visibility', s)
    return s


@rule((1, 5, 67), _('automaticMelismata turned on by default'))
def conv(s):
    if re.search(r'\addlyrics', s) \
            and re.search('automaticMelismata', s) is None:
        stderr_write(NOT_SMART % "automaticMelismata")
        stderr_write(
            _("automaticMelismata is turned on by default since 1.5.67."))
        stderr_write('\n')
        raise FatalConversionError()
    return s


@rule((1, 5, 68), 'ly-set-X-property -> ly-set-X-property!')
def conv(s):
    s = re.sub('ly-set-grob-property([^!])', 'ly-set-grob-property!\1', s)
    s = re.sub('ly-set-mus-property([^!])', 'ly-set-mus-property!\1', s)
    return s


@rule((1, 5, 71), 'extent-[XY] -> [XY]-extent')
def conv(s):
    s = re.sub('extent-X', 'X-extent', s)
    s = re.sub('extent-Y', 'Y-extent', s)
    return s


@rule((1, 5, 72), 'set! point-and-click -> set-point-and-click!')
def conv(s):
    s = re.sub(r"#\(set! +point-and-click +line-column-location\)",
                 "#(set-point-and-click! 'line-column)", s)
    s = re.sub(r"#\(set![ \t]+point-and-click +line-location\)",
                 "#(set-point-and-click! 'line)", s)
    s = re.sub(r'#\(set! +point-and-click +#f\)',
                 "#(set-point-and-click! 'none)", s)
    return s


@rule((1, 6, 5), 'Stems: flag-style -> stroke-style; style -> flag-style')
def conv(s):
    s = re.sub('flag-style', 'stroke-style', s)
    s = re.sub(r"""Stem([ ]+)\\override #'style""",
                 r"""Stem \\override #'flag-style""", s)
    s = re.sub(r"""Stem([ ]+)\\set([ ]+)#'style""",
                 r"""Stem \\set #'flag-style""", s)
    return s


def subst_req_name(match):
    return "(make-music-by-name \'%sEvent)" % regularize_id(match.group(1))


@rule((1, 7, 1), 'ly-make-music foo_bar_req -> make-music-by-name FooBarEvent')
def conv(s):
    s = re.sub(
        '\\(ly-make-music *"([A-Z][a-z_]+)_req"\\)', subst_req_name, s)
    s = re.sub('Request_chord', 'EventChord', s)
    return s


spanner_subst = {
    "text": 'TextSpanEvent',
    "decrescendo": 'DecrescendoEvent',
    "crescendo": 'CrescendoEvent',
    "Sustain": 'SustainPedalEvent',
    "slur": 'SlurEvent',
    "UnaCorda": 'UnaCordaEvent',
    "Sostenuto": 'SostenutoEvent',
}


def subst_ev_name(match):
    stype = 'STOP'
    if re.search('start', match.group(1)):
        stype = 'START'
    mtype = spanner_subst[match.group(2)]
    return "(make-span-event '%s %s)" % (mtype, stype)


def subst_definition_ev_name(match):
    return ' = #%s' % subst_ev_name(match)


def subst_inline_ev_name(match):
    s = subst_ev_name(match)
    return '#(ly-export %s)' % s


def subst_csp_definition(match):
    return ' = #(make-event-chord (list %s))' % subst_ev_name(match)


def subst_csp_inline(match):
    return '#(ly-export (make-event-chord (list %s)))' % subst_ev_name(match)


@rule((1, 7, 2), r'\\spanrequest -> #(make-span-event .. ), \script -> #(make-articulation .. )')
def conv(s):
    s = re.sub(
        r' *= *\\spanrequest *([^ ]+) *"([^"]+)"', subst_definition_ev_name, s)
    s = re.sub(
        r'\\spanrequest *([^ ]+) *"([^"]+)"', subst_inline_ev_name, s)
    s = re.sub(
        r' *= *\\commandspanrequest *([^ ]+) *"([^"]+)"', subst_csp_definition, s)
    s = re.sub(
        r'\\commandspanrequest *([^ ]+) *"([^"]+)"', subst_csp_inline, s)
    s = re.sub(r'ly-id ', 'ly-import ', s)

    s = re.sub(r' *= *\\script "([^"]+)"',
                 ' = #(make-articulation "\\1")', s)
    s = re.sub(r'\\script "([^"]+)"',
                 '#(ly-export (make-articulation "\\1"))', s)
    return s


@rule((1, 7, 3), 'ly- -> ly:')
def conv(s):
    s = re.sub(r'\(ly-', '(ly:', s)

    changed = [
        r'duration\?',
        r'font-metric\?',
        r'molecule\?',
        r'moment\?',
        r'music\?',
        r'pitch\?',
        'make-duration',
        'music-duration-length',
        'duration-log',
        'duration-dotcount',
        'intlog2',
        'duration-factor',
        'transpose-key-alist',
        'get-system',
        'get-broken-into',
        'get-original',
        'set-point-and-click!',
        'make-moment',
        'make-pitch',
        'pitch-octave',
        'pitch-alteration',
        'pitch-notename',
        'pitch-semitones',
        r'pitch<\?',
        r'dir\?',
        'music-duration-compress',
        'set-point-and-click!'
    ]

    origre = r'\b(%s)' % '|'.join(changed)

    s = re.sub(origre, r'ly:\1', s)
    s = re.sub('set-point-and-click!', 'set-point-and-click', s)
    return s


@rule((1, 7, 4), '<< >> -> < <  > >')
def conv(s):
    if re.search('new-chords-done', s):
        return s

    s = re.sub(r'<<', '< <', s)
    s = re.sub(r'>>', '> >', s)
    return s


@rule((1, 7, 5), '\\transpose TO -> \\transpose FROM  TO')
def conv(s):
    s = re.sub(r"\\transpose", r"\\transpose c'", s)
    s = re.sub(r"\\transpose c' *([a-z]+)'", r"\\transpose c \1", s)
    return s


@rule((1, 7, 6), r'note\\script -> note-\script')
def conv(s):
    kws = ['arpeggio',
           'sustainDown',
           'sustainUp',
           'f',
           'p',
           'pp',
           'ppp',
           'fp',
           'ff',
           'mf',
           'mp',
           'sfz',
           ]

    origstr = '|'.join(kws)
    s = re.sub(r'([^_^-])\\(%s)\b' % origstr, r'\1-\\\2', s)
    return s


@rule((1, 7, 10), r"\property ChordName #'style -> #(set-chord-name-style 'style)")
def conv(s):
    s = re.sub(r"\\property *ChordNames *\. *ChordName *\\(set|override) *#'style *= *#('[a-z]+)",
                 r"#(set-chord-name-style \2)", s)
    s = re.sub(r"\\property *ChordNames *\. *ChordName *\\revert *#'style",
                 r"", s)
    return s


@rule((1, 7, 11), "transpose-pitch -> pitch-transpose")
def conv(s):
    s = re.sub(r"ly:transpose-pitch", "ly:pitch-transpose", s)
    return s


@rule((1, 7, 13), "ly:XX-molecule-YY -> ly:molecule-XX-YY")
def conv(s):
    s = re.sub(r"ly:get-molecule-extent", "ly:molecule-get-extent", s)
    s = re.sub(r"ly:set-molecule-extent!", "ly:molecule-set-extent!", s)
    s = re.sub(r"ly:add-molecule", "ly:molecule-add", s)
    s = re.sub(r"ly:combine-molecule-at-edge",
                 "ly:molecule-combine-at-edge", s)
    s = re.sub(r"ly:align-to!", "ly:molecule-align-to!", s)
    return s


@rule((1, 7, 15), "linewidth = -1 -> raggedright = ##t")
def conv(s):
    s = re.sub(
        r"linewidth *= *-[0-9.]+ *(\\mm|\\cm|\\in|\\pt)?", 'raggedright = ##t', s)
    return s


@rule((1, 7, 16), "divisiomaior -> divisioMaior")
def conv(s):
    s = re.sub("divisiomaior",
                 "divisioMaior", s)
    s = re.sub("divisiominima",
                 "divisioMinima", s)
    s = re.sub("divisiomaxima",
                 "divisioMaxima", s)
    return s


@rule((1, 7, 17), "Skip_req  -> Skip_event")
def conv(s):
    s = re.sub("Skip_req_swallow_translator",
                 "Skip_event_swallow_translator", s)
    return s


@rule((1, 7, 18), "groupOpen/Close  -> start/stopGroup, #'outer  -> #'enclose-bounds")
def conv(s):
    s = re.sub("groupOpen",
                 "startGroup", s)
    s = re.sub("groupClose",
                 "stopGroup", s)
    s = re.sub("#'outer",
                 "#'enclose-bounds", s)

    return s


@rule((1, 7, 19), _("remove %s") % "GraceContext")
def conv(s):
    if re.search(r'\\GraceContext', s):
        stderr_write(NOT_SMART % "GraceContext")
        stderr_write(FROM_TO
                     % ("GraceContext", "#(add-to-grace-init .. )"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()

    s = re.sub('HaraKiriStaffContext', 'RemoveEmptyStaffContext', s)
    return s


@rule((1, 7, 22), "#'type -> #'style")
def conv(s):
    s = re.sub(
        r"(set|override|revert) *#'type",
        r"\1 #'style",
        s)
    return s


@rule((1, 7, 23), "barNonAuto -> automaticBars")
def conv(s):
    s = re.sub(
        "barNonAuto *= *##t",
        "automaticBars = ##f",
        s)
    s = re.sub(
        "barNonAuto *= *##f",
        "automaticBars = ##t",
        s)
    return s


@rule((1, 7, 24), _("cluster syntax"))
def conv(s):
    if re.search(r'-(start|stop)Cluster', s):
        stderr_write(NOT_SMART % _("cluster syntax"))
        stderr_write(UPDATE_MANUALLY)

        raise FatalConversionError()
    return s


@rule((1, 7, 28), _("new Pedal style syntax"))
def conv(s):
    s = re.sub(r"\\property *Staff\.(Sustain|Sostenuto|UnaCorda)Pedal *\\(override|set) *#'pedal-type *",
                 r"\\property Staff.pedal\1Style ", s)
    s = re.sub(
        r"\\property *Staff\.(Sustain|Sostenuto|UnaCorda)Pedal *\\revert *#'pedal-type", '', s)
    return s


def sub_chord(m):
    s = m.group(1)

    origstr = '<%s>' % s
    if re.search(r'\\\\', s):
        return origstr

    if re.search(r'\\property', s):
        return origstr

    if re.match(r'^\s*\)?\s*\\[a-zA-Z]+', s):
        return origstr

    durs = []

    def sub_durs(m, durs=durs):
        durs.append(m.group(2))
        return m.group(1)

    s = re.sub(r"([a-z]+[,'!? ]*)([0-9]+\.*)", sub_durs, s)
    dur_str = ''

    for d in durs:
        if dur_str == '':
            dur_str = d
        if dur_str != d:
            return '<%s>' % m.group(1)

    pslur_strs = ['']
    dyns = ['']
    slur_strs = ['']

    last_str = ''
    while last_str != s:
        last_str = s

        def sub_tremolos(m, slur_strs=slur_strs):
            tr = m.group(2)
            if tr not in slur_strs:
                slur_strs.append(tr)
            return m.group(1)

        s = re.sub(r"([a-z]+[',!? ]*)(:[0-9]+)",
                     sub_tremolos, s)

        def sub_dyn_end(m, dyns=dyns):
            dyns.append(r' \!')
            return ' ' + m.group(2)

        s = re.sub(r'(\\!)\s*([a-z]+)', sub_dyn_end, s)

        def sub_slurs(m, slur_strs=slur_strs):
            if '-)' not in slur_strs:
                slur_strs.append(')')
            return m.group(1)

        def sub_p_slurs(m, slur_strs=slur_strs):
            if r'-\)' not in slur_strs:
                slur_strs.append(r'\)')
            return m.group(1)

        s = re.sub(r"\)[ ]*([a-z]+)", sub_slurs, s)
        s = re.sub(r"\\\)[ ]*([a-z]+)", sub_p_slurs, s)

        def sub_begin_slurs(m, slur_strs=slur_strs):
            if '-(' not in slur_strs:
                slur_strs.append('(')
            return m.group(1)

        s = re.sub(r"([a-z]+[,'!?0-9 ]*)\(",
                     sub_begin_slurs, s)

        def sub_begin_p_slurs(m, slur_strs=slur_strs):
            if r'-\(' not in slur_strs:
                slur_strs.append(r'\(')
            return m.group(1)

        s = re.sub(r"([a-z]+[,'!?0-9 ]*)\\\(",
                     sub_begin_p_slurs, s)

        def sub_dyns(m, slur_strs=slur_strs):
            s = m.group(0)
            if s == '@STARTCRESC@':
                slur_strs.append("\\<")
            elif s == '@STARTDECRESC@':
                slur_strs.append("\\>")
            elif s == r'-?\\!':
                slur_strs.append('\\!')
            return ''

        s = re.sub(r'@STARTCRESC@', sub_dyns, s)
        s = re.sub(r'-?\\!', sub_dyns, s)

        def sub_articulations(m, slur_strs=slur_strs):
            a = m.group(1)
            if a not in slur_strs:
                slur_strs.append(a)
            return ''

        s = re.sub(r"([_^-]\@ACCENT\@)", sub_articulations,
                     s)
        s = re.sub(r"([_^-]\\[a-z]+)", sub_articulations,
                     s)
        s = re.sub(r"([_^-][>_.+|^-])", sub_articulations,
                     s)
        s = re.sub(r'([_^-]"[^"]+")', sub_articulations,
                     s)

        def sub_pslurs(m, slur_strs=slur_strs):
            slur_strs.append(' \\)')
            return m.group(1)
        s = re.sub(r"\\\)[ ]*([a-z]+)", sub_pslurs, s)

    # end of while <>

    suffix = ''.join(slur_strs) + ''.join(pslur_strs) \
             + ''.join(dyns)

    return '@STARTCHORD@%s@ENDCHORD@%s%s' % (s, dur_str, suffix)


def sub_chords(s):
    simend = '>'
    simstart = '<'
    chordstart = '<<'
    chordend = '>>'
    marker_str = '%% new-chords-done %%'

    if re.search(marker_str, s):
        return s
    s = re.sub('<<', '@STARTCHORD@', s)
    s = re.sub('>>', '@ENDCHORD@', s)

    s = re.sub(r'\\<', '@STARTCRESC@', s)
    s = re.sub(r'\\>', '@STARTDECRESC@', s)
    s = re.sub(r'([_^-])>', r'\1@ACCENT@', s)
    s = re.sub(r'<([^<>{}]+)>', sub_chord, s)

    # add dash: -[, so that [<<a b>> c d] becomes
    #                      <<a b>>-[ c d]
    # and gets skipped by articulation_substitute
    s = re.sub(r'\[ *(@STARTCHORD@[^@]+@ENDCHORD@[0-9.]*)',
                 r'\1-[', s)
    s = re.sub(r'\\! *(@STARTCHORD@[^@]+@ENDCHORD@[0-9.]*)',
                 r'\1-\\!', s)

    s = re.sub(r'<([^?])', r'%s\1' % simstart, s)
    s = re.sub(r'>([^?])', r'%s\1' % simend,  s)
    s = re.sub('@STARTCRESC@', r'\\<', s)
    s = re.sub('@STARTDECRESC@', r'\\>', s)
    s = re.sub(r'\\context *Voice *@STARTCHORD@',
                 '@STARTCHORD@', s)
    s = re.sub('@STARTCHORD@', chordstart, s)
    s = re.sub('@ENDCHORD@', chordend, s)
    s = re.sub(r'@ACCENT@', '>', s)
    return s


markup_start = re.compile(r"([-^_]|\\mark)\s*(#\s*'\s*)\(")
musicglyph = re.compile(r"\(\s*music\b")
columns = re.compile(r"\(\s*columns\b")
submarkup_start = re.compile(r"\(\s*([a-zA-Z]+)")
leftpar = re.compile(r"\(")
rightpar = re.compile(r"\)")


def text_markup(s):
    result = ''
    # Find the beginning of each markup:
    match = markup_start.search(s)
    while match:
        result = result + s[:match.end(1)] + r" \markup"
        s = s[match.end(2):]
        # Count matching parentheses to find the end of the
        # current markup:
        nesting_level = 0
        pars = re.finditer(r"[()]", s)
        for par in pars:
            if par.group() == '(':
                nesting_level = nesting_level + 1
            else:
                nesting_level = nesting_level - 1
            if nesting_level == 0:
                markup_end = par.end()
                break
        # The full markup in old syntax:
        markup = s[:markup_end]
        # Modify to new syntax:
        markup = musicglyph.sub(r"{\\musicglyph", markup)
        markup = columns.sub(r"{", markup)
        markup = submarkup_start.sub(r"{\\\1", markup)
        markup = leftpar.sub("{", markup)
        markup = rightpar.sub("}", markup)

        result = result + markup
        # Find next markup
        s = s[markup_end:]
        match = markup_start.search(s)
    result = result + s
    return result


def articulation_substitute(s):
    s = re.sub(r"""([^-])\[ *(\\?\)?[a-z]+[,']*[!?]?[0-9:]*\.*)""",
                 r"\1 \2[", s)
    s = re.sub(r"""([^-])\\\) *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
                 r"\1 \2\\)", s)
    s = re.sub(r"""([^-\\])\) *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
                 r"\1 \2)", s)
    s = re.sub(r"""([^-])\\! *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
                 r"\1 \2\\!", s)
    return s


string_or_scheme = re.compile('("(?:[^"\\\\]|\\\\.)*")|(#\\s*\'?\\s*\\()')

# Only apply articulation_substitute () outside strings and
# Scheme expressions:


def smarter_articulation_subst(s):
    result = ''
    # Find the beginning of next string or Scheme expr.:
    match = string_or_scheme.search(s)
    while match:
        # Convert the preceding LilyPond code:
        previous_chunk = s[:match.start()]
        result = result + articulation_substitute(previous_chunk)
        if match.group(1):  # Found a string
            # Copy the string to output:
            result = result + match.group(1)
            s = s[match.end(1):]
        else:  # Found a Scheme expression. Count
            # matching parentheses to find its end
            s = s[match.start():]
            nesting_level = 0
            pars = re.finditer(r"[()]", s)
            for par in pars:
                if par.group() == '(':
                    nesting_level = nesting_level + 1
                else:
                    nesting_level = nesting_level - 1
                if nesting_level == 0:
                    scheme_end = par.end()
                    break
            # Copy the Scheme expression to output:
            result = result + s[:scheme_end]
            s = s[scheme_end:]
        # Find next string or Scheme expression:
        match = string_or_scheme.search(s)
    # Convert the remainder of the file
    result = result + articulation_substitute(s)
    return result


def conv_relative(s):
    if re.search(r"\\relative", s):
        s = "#(ly:set-option 'old-relative)\n" + s

    return s


@rule((1, 9, 0), _("""New relative mode,
Postfix articulations, new text markup syntax, new chord syntax."""))
def conv(s):
    s = re.sub(r"#'\(\)", "@SCM_EOL@", s)
    s = conv_relative(s)
    s = sub_chords(s)

    s = text_markup(s)
    s = smarter_articulation_subst(s)
    s = re.sub("@SCM_EOL@", "#'()", s)
    return s


@rule((1, 9, 1), _("Remove - before articulation"))
def conv(s):
    if re.search("font-style", s):
        stderr_write(NOT_SMART % "font-style")
        stderr_write(UPDATE_MANUALLY)

        raise FatalConversionError()

    s = re.sub(r'-\\markup', r'@\\markup', s)
    s = re.sub(r'-\\', r'\\', s)
    s = re.sub(r'-\)', ')', s)
    s = re.sub(r'-\(', '(', s)
    s = re.sub(r'-\[', '[', s)
    s = re.sub(r'-\]', ']', s)
    s = re.sub('-~', '~', s)
    s = re.sub(r'@\\markup', r'-\\markup', s)
    return s


@rule((1, 9, 2), "\\newcontext -> \\new")
def conv(s):
    s = re.sub('ly:set-context-property',
                 'ly:set-context-property!', s)
    s = re.sub('\\\\newcontext', '\\\\new', s)
    s = re.sub('\\\\grace[\t\n ]*([^{ ]+)',
                 r'\\grace { \1 }', s)
    s = re.sub("\\\\grace[\t\n ]*{([^}]+)}",
                 r"""\\grace {
\\property Voice.Stem \\override #'stroke-style = #"grace"
  \1
  \\property Voice.Stem \\revert #'stroke-style }
""", s)
    return s


@rule((1, 9, 3), (_("%s misspelling") % "\\acciaccatura") +
      ", fingerHorizontalDirection -> fingeringOrientations")
def conv(s):
    s = re.sub('accacciatura',
                 'acciaccatura', s)

    if re.search("context-spec-music", s):
        stderr_write(NOT_SMART % "context-spec-music")
        stderr_write(UPDATE_MANUALLY)

        raise FatalConversionError()

    s = re.sub('fingerHorizontalDirection *= *#(LEFT|-1)',
                 "fingeringOrientations = #'(up down left)", s)
    s = re.sub('fingerHorizontalDirection *= *#(RIGHT|1)',
                 "fingeringOrientations = #'(up down right)", s)
    return s


@rule((1, 9, 4), _('Swap < > and << >>'))
def conv(s):
    if re.search('\\figures', s):
        warning(_("attempting automatic \\figures conversion.  Check results!"))

    def figures_replace(m):
        s = m.group(1)
        s = re.sub('<', '@FIGOPEN@', s)
        s = re.sub('>', '@FIGCLOSE@', s)
        return '\\figures { %s }' % s

    s = re.sub(r'\\figures[ \t\n]*{([^}]+)}', figures_replace, s)
    s = re.sub(r'\\<', '@STARTCRESC@', s)
    s = re.sub(r'\\>', '@STARTDECRESC@', s)
    s = re.sub(r'([-^_])>', r'\1@ACCENT@', s)
    s = re.sub(r'<<', '@STARTCHORD@', s)
    s = re.sub(r'>>', '@ENDCHORD@', s)
    s = re.sub(r'>', '@ENDSIMUL@', s)
    s = re.sub(r'<', '@STARTSIMUL@', s)
    s = re.sub('@STARTDECRESC@', '\\>', s)
    s = re.sub('@STARTCRESC@', '\\<', s)
    s = re.sub('@ACCENT@', '>', s)
    s = re.sub('@ENDCHORD@', '>', s)
    s = re.sub('@STARTCHORD@', '<', s)
    s = re.sub('@STARTSIMUL@', '<<', s)
    s = re.sub('@ENDSIMUL@', '>>', s)
    s = re.sub('@FIGOPEN@', '<', s)
    s = re.sub('@FIGCLOSE@', '>', s)
    return s


@rule((1, 9, 5), 'HaraKiriVerticalGroup -> RemoveEmptyVerticalGroup')
def conv(s):
    s = re.sub('HaraKiriVerticalGroup', 'RemoveEmptyVerticalGroup', s)
    return s


@rule((1, 9, 6), _('deprecate %s') % 'ly:get-font')
def conv(s):
    if re.search("ly:get-font", s):
        stderr_write(NOT_SMART % "ly:get-font")
        stderr_write(FROM_TO
                     % ("(ly:paper-get-font (ly:grob-get-paper foo) .. )",
                         "(ly:paper-get-font (ly:grob-get-paper foo) .. )"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()

    if re.search(r"\\pitch *#", s):
        stderr_write(NOT_SMART % "\\pitch")
        stderr_write(_("Use Scheme code to construct arbitrary note events."))
        stderr_write('\n')

        raise FatalConversionError()
    return s


@rule((1, 9, 7), _('''use symbolic constants for alterations,
remove \\outputproperty, move ly:verbose into ly:get-option'''))
def conv(s):
    def sub_alteration(m):
        alt = m.group(3)
        alt = {
            '-1': 'FLAT',
            '-2': 'DOUBLE-FLAT',
            '0': 'NATURAL',
            '1': 'SHARP',
            '2': 'DOUBLE-SHARP',
        }[alt]

        return '(ly:make-pitch %s %s %s)' % (m.group(1), m.group(2),
                                             alt)

    s = re.sub("\\(ly:make-pitch *([0-9-]+) *([0-9-]+) *([0-9-]+) *\\)",
                 sub_alteration, s)

    s = re.sub("ly:verbose", "ly:get-option 'verbose", s)

    m = re.search("\\\\outputproperty #([^#]+)[\t\n ]*#'([^ ]+)", s)
    if m:
        stderr_write(_(
            r"""\outputproperty found,
Please hand-edit, using

  \applyoutput #(outputproperty-compatibility %s '%s <GROB PROPERTY VALUE>)

as a substitution text.""") % (m.group(1), m.group(2)))
        raise FatalConversionError()

    if re.search("ly:(make-pitch|pitch-alteration)", s) \
            or re.search("keySignature", s):
        stderr_write(NOT_SMART % "pitches")
        stderr_write(
            _("""The alteration field of Scheme pitches was multiplied by 2
to support quarter tone accidentals.  You must update the following constructs manually:

* calls of ly:make-pitch and ly:pitch-alteration
* keySignature settings made with \\property
"""))
        raise FatalConversionError()
    return s


@rule((1, 9, 8), "dash-length -> dash-fraction")
def conv(s):
    if re.search("dash-length", s):
        stderr_write(NOT_SMART % "dash-length")
        stderr_write(FROM_TO % ("dash-length", "dash-fraction"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    return s


@rule((2, 1, 1), "font-relative-size -> font-size")
def conv(s):
    def func(match):
        return "#'font-size = #%d" % (2*int(match.group(1)))

    s = re.sub(r"#'font-relative-size\s*=\s*#\+?([0-9-]+)", func, s)
    s = re.sub(r"#'font-family\s*=\s*#'ancient",
                 r"#'font-family = #'music", s)
    return s


@rule((2, 1, 2), "ly:get-music-length -> ly:music-length")
def conv(s):
    s = re.sub(r"ly:get-music-length", "ly:music-length", s)
    return s


@rule((2, 1, 3), "stanza -> instrument")
def conv(s):
    s = re.sub(r"\.\s+stz=", ". instr ", s)
    return s


@rule((2, 1, 4), _("removal of automaticMelismata; use melismaBusyProperties instead."))
def conv(s):
    def func(match):
        c = match.group(1)
        b = match.group(2)

        if b == 't':
            if c == 'Score':
                return ''
            return r" \property %s.melismaBusyProperties \unset" % c

        assert b == 'f', "Value must be ##t or ##f and not ##%s" % b
        return r"\property %s.melismaBusyProperties = #'(melismaBusy)" % c

    s = re.sub(
        r"\\property ([a-zA-Z]+)\s*\.\s*automaticMelismata\s*=\s*##([ft])", func, s)
    return s


@rule((2, 1, 7), "\\translator Staff -> \\change Staff")
def conv(s):
    s = re.sub(r"\\translator\s+([a-zA-Z]+)", r"\\change \1", s)
    return s


@rule((2, 1, 10), "\\newaddlyrics -> \\lyricsto")
def conv(s):
    s = re.sub(r"\\newaddlyrics", r"\\lyricsto", s)
    return s


@rule((2, 1, 11), """\\include "paper16.ly" -> #(set-staff-size 16)
\\note #3 #1 #1 -> \\note #"8." #1
""")
def conv(s):
    s = re.sub(r'\\include\s*"paper([0-9]+)(-init)?.ly"',
                 r"#(set-staff-size \1)", s)

    def sub_note(match):
        dur = ''
        log = int(match.group(1))
        dots = int(match.group(2))

        if log >= 0:
            dur = '%d' % (1 << log)
        else:
            dur = {-1: 'breve',
                   -2: 'longa',
                   -3: 'maxima'}[log]

        dur += ('.' * dots)

        return r'\note #"%s" #%s' % (dur, match.group(3))

    s = re.sub(r'\\note\s+#([0-9-]+)\s+#([0-9]+)\s+#([0-9.-]+)',
                 sub_note, s)
    return s


@rule((2, 1, 12), "OttavaSpanner -> OttavaBracket")
def conv(s):
    s = re.sub(r"OttavaSpanner", r"OttavaBracket", s)
    return s


@rule((2, 1, 13), "set-staff-size -> set-global-staff-size")
def conv(s):
    s = re.sub(r"\(set-staff-size ", r"(set-global-staff-size ", s)
    return s


@rule((2, 1, 14), "style = dotted -> dash-fraction = 0")
def conv(s):
    s = re.sub(r"#'style\s*=\s*#'dotted-line",
                 r"#'dash-fraction = #0.0 ", s)
    return s


@rule((2, 1, 15), "LyricsVoice . instr(ument) -> vocalName")
def conv(s):
    s = re.sub(r'LyricsVoice\s*\.\s*instrument\s*=\s*("[^"]*")',
                 r'LyricsVoice . vocalName = \1', s)

    s = re.sub(r'LyricsVoice\s*\.\s*instr\s*=\s*("[^"]*")',
                 r'LyricsVoice . vocNam = \1', s)
    return s


@rule((2, 1, 16), '\\musicglyph #"accidentals-NUM" -> \\sharp/flat/etc.')
def conv(s):
    def sub_acc(m):
        d = {
            '4': 'doublesharp',
            '3': 'threeqsharp',
            '2': 'sharp',
            '1': 'semisharp',
            '0': 'natural',
            '-1': 'semiflat',
            '-2': 'flat',
            '-3': 'threeqflat',
            '-4': 'doubleflat'}
        return '\\%s' % d[m.group(1)]

    s = re.sub(r'\\musicglyph\s*#"accidentals-([0-9-]+)"',
                 sub_acc, s)
    return s


@rule((2, 1, 17), _("\\partcombine syntax change to \\newpartcombine"))
def conv(s):

    if re.search(r'\\partcombine', s):
        stderr_write(NOT_SMART % "\\partcombine")
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()

    # this rule doesn't really work,
    # too lazy to figure out why.
    s = re.sub(r'\\context\s+Voice\s*=\s*one\s*\\partcombine\s+Voice\s*\\context\s+Thread\s*=\s*one(.*)\s*'
                 + r'\\context\s+Thread\s*=\s*two',
                 '\\\\newpartcombine\n\\1\n', s)
    return s


@rule((2, 1, 18), """\\newpartcombine -> \\partcombine,
\\autochange Staff -> \\autochange
""")
def conv(s):
    s = re.sub(r'\\newpartcombine', r'\\partcombine', s)
    s = re.sub(r'\\autochange\s+Staff', r'\\autochange ', s)
    return s


@rule((2, 1, 19), _("""Drum notation changes, Removing \\chordmodifiers, \\notenames.
Harmonic notes. Thread context removed. Lyrics context removed."""))
def conv(s):
    if re.search('include "drumpitch', s):
        stderr_write(_("Drums found. Enclose drum notes in \\drummode"))

    s = re.sub(r'\\include "drumpitch-init.ly"', '', s)

    s = re.sub(r'\\pitchnames ', 'pitchnames = ', s)
    s = re.sub(r'\\chordmodifiers ', 'chordmodifiers = ', s)
    s = re.sub(r'\bdrums\b\s*=', 'drumContents = ', s)
    s = re.sub(r'\\drums\b', r'\\drumContents ', s)

    if re.search('drums->paper', s):
        stderr_write(_("\n%s found. Check file manually!\n") %
                     _("Drum notation"))

    s = re.sub(r"""\\apply\s+#\(drums->paper\s+'([a-z]+)\)""",
                 r"""\\property DrumStaff.drumStyleTable = #\1-style""",
                 s)

    if re.search('Thread', s):
        stderr_write(_("\n%s found. Check file manually!\n") % "Thread")

    s = re.sub(r"""(\\once\s*)?\\property\s+Thread\s*\.\s*NoteHead\s*"""
                 + r"""\\(set|override)\s*#'style\s*=\s*#'harmonic"""
                 + r"""\s+([a-z]+[,'=]*)([0-9]*\.*)""", r"""<\3\\harmonic>\4""", s)

    s = re.sub(r"""\\new Thread""", r"""\\context Voice""", s)
    s = re.sub(r"""Thread""", """Voice""", s)

    if re.search('\bLyrics\b', s):
        stderr_write(_("\n%s found. Check file manually!\n") % "Lyrics")

    s = re.sub(r"""LyricsVoice""", r"""L@ricsVoice""", s)
    s = re.sub(r"""\bLyrics\b""", r"""LyricsVoice""", s)
    s = re.sub(r"""LyricsContext""", r"""LyricsVoiceContext""", s)
    s = re.sub(r"""L@ricsVoice""", r"""LyricsVoice""", s)
    return s


@rule((2, 1, 20), "nonevent-skip -> skip-music")
def conv(s):
    s = re.sub(r'nonevent-skip', 'skip-music', s)
    return s


@rule((2, 1, 21), """molecule-callback -> print-function,
brew_molecule -> print
brew-new-markup-molecule -> Text_item::print
LyricsVoice -> Lyrics
tupletInvisible -> TupletBracket \\set #'transparent
%s.
""" % (_("remove %s") % "Grob::preset_extent"))
def conv(s):
    s = re.sub(r'molecule-callback', 'print-function', s)
    s = re.sub(r'brew_molecule', 'print', s)
    s = re.sub(r'brew-new-markup-molecule', 'Text_item::print', s)
    s = re.sub(r'LyricsVoice', 'Lyrics', s)
    s = re.sub(r'tupletInvisible',
                 r"TupletBracket \\set #'transparent", s)
#       s = re.sub (r'molecule', 'collage', s)
# molecule -> collage
    s = re.sub(r"\\property\s+[a-zA-Z]+\s*\.\s*[a-zA-Z]+\s*"
                 + r"\\set\s*#'X-extent-callback\s*=\s*#Grob::preset_extent",
                 "", s)
    return s


@rule((2, 1, 22), """%s
        \\set A.B = #C , \\unset A.B
        \\override A.B #C = #D, \\revert A.B #C

""" % _("new syntax for property settings:"))
def conv(s):
    s = re.sub(r'(\\property[^=]+)=\s*([-0-9]+)',
                 r'\1= #\2', s)
    s = re.sub(r'\\property\s+([^. ]+)\s*\.\s*([^\\=]+)\s*\\(set|override)',
                 r"\\overrid@ \1.\2 ", s)
    s = re.sub(r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*=\s*',
                 r'\\s@t \1.\2 = ', s)
    s = re.sub(r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*\\unset',
                 r'\\uns@t \1.\2 ', s)
    s = re.sub(r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*\\revert'
                 + r"\s*#'([-a-z0-9_]+)",
                 r"\\rev@rt \1.\2 #'\3", s)
    s = re.sub(r'Voice\.', '', s)
    s = re.sub(r'Lyrics\.', '', s)
    s = re.sub(r'ChordNames\.', '', s)

    s = re.sub('rev@rt', 'revert', s)
    s = re.sub('s@t', 'set', s)
    s = re.sub('overrid@', 'override', s)

    s = re.sub('molecule', 'stencil', s)
    s = re.sub('Molecule', 'Stencil', s)
    return s


@rule((2, 1, 23), _("Property setting syntax in \\translator{ }"))
def conv(s):
    def subst_in_trans(match):
        s = match.group(0)
        s = re.sub(r'\s([a-zA-Z]+)\s*\\override',
                   r' \\override \1', s)
        s = re.sub(r'\s([a-zA-Z]+)\s*\\set',
                   r' \\override \1', s)
        s = re.sub(r'\s([a-zA-Z]+)\s*\\revert',
                   r' \\revert \1', s)
        return s
    s = re.sub(r'\\(translator|with)\s*{[^}]+}',  subst_in_trans, s)

    def sub_abs(m):

        context = m.group('context')
        d = m.groupdict()
        if context:
            context = " '%s" % context[:-1]  # -1: remove .
        else:
            context = ''

        d['context'] = context

        return r"""#(override-auto-beam-setting %(prop)s %(num)s %(den)s%(context)s)""" % d

    s = re.sub(r"""\\override\s*(?P<context>[a-zA-Z]+\s*\.\s*)?autoBeamSettings"""
                 + r"""\s*#(?P<prop>[^=]+)\s*=\s*#\(ly:make-moment\s+(?P<num>\d+)\s+(?P<den>\d)\s*\)""",
                 sub_abs, s)
    return s


@rule((2, 1, 24), "music-list? -> ly:music-list?")
def conv(s):
    s = re.sub(r'music-list\?', 'ly:music-list?', s)
    s = re.sub(r'\|\s*~', '~ |', s)
    return s


@rule((2, 1, 25), _("Scheme grob function renaming"))
def conv(s):
    s = re.sub(r'ly:get-spanner-bound', 'ly:spanner-get-bound', s)
    s = re.sub(r'ly:get-extent', 'ly:grob-extent', s)
    s = re.sub(r'ly:get-system', 'ly:grob-system', s)
    s = re.sub(r'ly:get-original', 'ly:grob-original', s)
    s = re.sub(r'ly:get-parent', 'ly:grob-parent', s)
    s = re.sub(r'ly:get-broken-into', 'ly:spanner-broken-into', s)
    s = re.sub(r'Melisma_engraver', 'Melisma_translator', s)
    if re.search("ly:get-paper-variable", s):
        stderr_write(NOT_SMART % "ly:paper-get-variable")
        stderr_write(_('Use %s\n') % '(ly:paper-lookup (ly:grob-paper ))')
        raise FatalConversionError()

    s = re.sub(r'\\defaultAccidentals',
                 "#(set-accidental-style 'default)", s)
    s = re.sub(r'\\voiceAccidentals', "#(set-accidental-style 'voice)", s)
    s = re.sub(r'\\modernAccidentals',
                 "#(set-accidental-style 'modern)", s)
    s = re.sub(r'\\modernCautionaries',
                 "#(set-accidental-style 'modern-cautionary)", s)
    s = re.sub(r'\\modernVoiceAccidental',
                 "#(set-accidental-style 'modern-voice)", s)
    s = re.sub(r'\\modernVoiceCautionaries',
                 "#(set-accidental-style 'modern-voice-cautionary)", s)
    s = re.sub(r'\\pianoAccidentals', "#(set-accidental-style 'piano)", s)
    s = re.sub(r'\\pianoCautionaries',
                 "#(set-accidental-style 'piano-cautionary)", s)
    s = re.sub(r'\\forgetAccidentals',
                 "#(set-accidental-style 'forget)", s)
    s = re.sub(r'\\noResetKey', "#(set-accidental-style 'no-reset)", s)
    return s


@rule((2, 1, 26), _("More Scheme function renaming"))
def conv(s):
    s = re.sub('ly:set-grob-property!', 'ly:grob-set-property!', s)
    s = re.sub('ly:set-mus-property!', 'ly:music-set-property!', s)
    s = re.sub('ly:set-context-property!', 'ly:context-set-property!', s)
    s = re.sub('ly:get-grob-property', 'ly:grob-property', s)
    s = re.sub('ly:get-mus-property', 'ly:music-property', s)
    s = re.sub('ly:get-context-property', 'ly:context-property', s)
    return s


@rule((2, 1, 27), "property transposing -> tuning")
def conv(s):
    def subst(m):
        (o, g) = divmod(int(m.group(2)), 12)

        lower_pitches = [x for x in [0, 2, 4, 5, 7, 9, 11, 12] if x <= g]
        s = len(lower_pitches) - 1
        a = g - lower_pitches[-1]

        s = 'cdefgab' [s]
        s += ['eses', 'es', '', 'is', 'isis'][a + 2]
        o += 1                  # c' is octave 0
        if o < 0:
            s += (-o) * ","
        elif o > 0:
            s += o * "'"

        return '\\transposition %s ' % s

    s = re.sub(r"\\set ([A-Za-z]+\s*\.\s*)?transposing\s*=\s*#([-0-9]+)",
                 subst, s)
    return s


@rule((2, 1, 28), """make-music-by-name -> make-music,
new syntax for setting \\arpeggioBracket""")
def conv(s):
    s = re.sub(r'make-music-by-name', 'make-music', s)
    s = re.sub(r"\\override\s+.*Arpeggio\s+#.print-function\s+=\s+\\arpeggioBracket",
                 r"\\arpeggioBracket", s)
    return s


@rule((2, 1, 29), '\\center -> \\center-align, \\translator -> \\context')
def conv(s):
    s = re.sub(r'\\center([^-])', r'\\center-align\1', s)
    s = re.sub(r'\\translator', r'\\context', s)
    return s


@rule((2, 1, 30), '''\\threeq{flat,sharp} -> \\sesqui{flat,sharp}
ly:get-mutable-properties -> ly:mutable-music-properties
centralCPosition -> middleCPosition
ly:unset-context-property -> ly:context-unset-property
ly:translator-find -> ly:context-find
ly:get-stencil-extent -> ly:stencil-extent
''')
def conv(s):
    s = re.sub(r'\\threeq(flat|sharp)', r'\\sesqui\1', s)
    s = re.sub(r'ly:stencil-get-extent',
                 'ly:stencil-extent', s)
    s = re.sub(r'ly:translator-find',
                 'ly:context-find', s)
    s = re.sub('ly:unset-context-property', 'ly:context-unset-property',
                 s)

    s = re.sub(r'ly:get-mutable-properties',
                 'ly:mutable-music-properties', s)
    s = re.sub(r'centralCPosition',
                 'middleCPosition', s)
    return s


@rule((2, 1, 31), 'remove \\alias Timing')
def conv(s):
    s = re.sub(r'\\alias\s*"?Timing"?', '', s)
    return s


@rule((2, 1, 33), 'breakAlignOrder -> break-align-orders.')
def conv(s):
    s = re.sub(r"(\\set\s+)?(?P<context>(Score\.)?)breakAlignOrder\s*=\s*#'(?P<list>[^\)]+)",
                 r"\n\\override \g<context>BreakAlignment #'break-align-orders = "
                 + r"#(make-vector 3 '\g<list>)", s)
    return s


@rule((2, 1, 34), 'set-paper-size -> set-default-paper-size.')
def conv(s):
    s = re.sub(r"\(set-paper-size",
                 "(set-default-paper-size", s)
    return s


@rule((2, 1, 36), 'ly:mutable-music-properties -> ly:music-mutable-properties')
def conv(s):
    s = re.sub(r"ly:mutable-music-properties",
                 "ly:music-mutable-properties", s)
    return s


@rule((2, 2, 0), _("bump version for release"))
def conv(s):
    return s


@rule((2, 3, 1), '\\apply -> \\applymusic')
def conv(s):
    return re.sub(r'\\apply\b', r'\\applymusic', s)


@rule((2, 3, 2), '\\FooContext -> \\Foo')
def conv(s):
    if re.search('textheight', s):
        stderr_write(NOT_SMART % "textheight")
        stderr_write(UPDATE_MANUALLY)
        stderr_write(
            _("""Page layout has been changed, using paper size and margins.
textheight is no longer used.
"""))
    s = re.sub(r'\\OrchestralScoreContext', r'\\Score', s)

    def func(m):
        if m.group(1) not in ['RemoveEmptyStaff',
                              'AncientRemoveEmptyStaffContext',
                              'EasyNotation']:
            return '\\' + m.group(1)
        return m.group(0)

    s = re.sub(r'\\([a-zA-Z]+)Context\b', func, s)
    s = re.sub('ly:paper-lookup', 'ly:output-def-lookup', s)
    return s


@rule((2, 3, 4), _('remove %s') % '\\notes')
def conv(s):
    s = re.sub(r'\\notes\b', '', s)
    return s


@rule((2, 3, 6), 'lastpagefill -> raggedlastbottom')
def conv(s):
    s = re.sub(r'lastpagefill\s*=\s*"?1"', 'raggedlastbottom = ##t', s)
    return s


@rule((2, 3, 8), 'remove \\consistsend, strip \\lyrics from \\lyricsto.')
def conv(s):
    s = re.sub(r'\\consistsend', r'\\consists', s)
    s = re.sub(r'\\lyricsto\s+("?[a-zA-Z]+"?)(\s*\\new Lyrics\s*)?\\lyrics',
                 r'\\lyricsto \1 \2', s)
    return s


@rule((2, 3, 9), 'neo_mensural -> neomensural, if-text-padding -> bound-padding')
def conv(s):
    s = re.sub(r'neo_mensural', 'neomensural', s)
    s = re.sub(r'if-text-padding', 'bound-padding', s)
    return s


@rule((2, 3, 10), '\\addlyrics -> \\oldaddlyrics, \\newlyrics -> \\addlyrics')
def conv(s):
    s = re.sub(r'\\addlyrics', r'\\oldaddlyrics', s)
    s = re.sub(r'\\newlyrics', r'\\addlyrics', s)
    if re.search(r"\\override\s*TextSpanner", s):
        stderr_write(
            "\nWarning: TextSpanner has been split into DynamicTextSpanner and TextSpanner\n")
    return s


@rule((2, 3, 11), '\\setMmRestFermata -> ^\\fermataMarkup')
def conv(s):
    s = re.sub(r'\\setMmRestFermata\s+(R[0-9.*/]*)',
                 r'\1^\\fermataMarkup', s)
    return s


@rule((2, 3, 12), '''\\newpage -> \\pageBreak, junk \\script{up,down,both},
soloADue -> printPartCombineTexts, #notes-to-clusters -> \\makeClusters
''')
def conv(s):
    s = re.sub(r'\\newpage', r'\\pageBreak', s)
    s = re.sub(r'\\scriptUp', r"""{
\\override TextScript  #'direction = #1
\\override Script  #'direction = #1
}""", s)
    s = re.sub(r'\\scriptDown', r"""{
  \\override TextScript  #'direction = #-1
  \\override Script  #'direction = #-1
}""", s)
    s = re.sub(r'\\scriptBoth', r"""{
  \\revert TextScript  #'direction
  \\revert Script  #'direction
}""", s)
    s = re.sub('soloADue', 'printPartCombineTexts', s)
    s = re.sub(r'\\applymusic\s*#notes-to-clusters',
                 r'\\makeClusters', s)

    s = re.sub(r'pagenumber\s*=', 'firstpagenumber = ', s)
    return s


@rule((2, 3, 16), _('''\\foo -> \\foomode (for chords, notes, etc.)
fold \\new FooContext \\foomode into \\foo.'''))
def conv(s):
    s = re.sub(r'\\chords\b', r'\\chordmode', s)
    s = re.sub(r'\\lyrics\b', r'\\lyricmode', s)
    s = re.sub(r'\\figures\b', r'\\figuremode', s)
    s = re.sub(r'\\notes\b', r'\\notemode', s)
    s = re.sub(r'\\drums\b', r'\\drummode', s)
    s = re.sub(r'\\chordmode\s*\\new ChordNames', r'\\chords', s)
    s = re.sub(r'\\new ChordNames\s*\\chordmode', r'\\chords', s)
    s = re.sub(r'\\new FiguredBass\s*\\figuremode', r'\\figures', s)
    s = re.sub(r'\\figuremode\s*\new FiguredBass', r'\\figures', s)
    s = re.sub(r'\\new DrumStaff\s*\\drummode', r'\\drums', s)
    s = re.sub(r'\\drummode\s*\\new DrumStaff', r'\\drums', s)

    return s


@rule((2, 3, 17), '''slurBoth -> slurNeutral, stemBoth -> stemNeutral, etc.
\\applymusic #(remove-tag 'foo) -> \\removeWithTag 'foo''')
def conv(s):
    s = re.sub(
        r'(slur|stem|phrasingSlur|tie|dynamic|dots|tuplet|arpeggio|)Both', r'\1Neutral', s)
    s = re.sub(r"\\applymusic\s*#\(remove-tag\s*'([a-z-0-9]+)\)",
                 r"\\removeWithTag #'\1", s)
    return s


@rule((2, 3, 18), 'Text_item -> Text_interface')
def conv(s):
    s = re.sub(r'Text_item', 'Text_interface', s)
    return s


@rule((2, 3, 22), 'paper -> layout, bookpaper -> paper')
def conv(s):
    s = re.sub(r'\\paper', r'\\layout', s)
    s = re.sub(r'\\bookpaper', r'\\paper', s)
    if re.search('paper-set-staff-size', s):
        warning(_('''staff size should be changed at top-level
with

  #(set-global-staff-size <STAFF-HEIGHT-IN-POINT>)

'''))

    s = re.sub(r'#\(paper-set-staff-size',
                 '%Use set-global-staff-size at toplevel\n% #(layout-set-staff-size', s)
    return s


@rule((2, 3, 23), r'\context Foo = NOTENAME -> \context Foo = "NOTENAME"')
def conv(s):
    s = re.sub(r'\\context\s+([a-zA-Z]+)\s*=\s*([a-z]+)\s',
                 r'\\context \1 = "\2" ',
                 s)
    return s


@rule((2, 3, 24), _('''regularize other identifiers'''))
def conv(s):
    def sub(m):
        return regularize_id(m.group(1))
    s = re.sub(r'(maintainer_email|maintainer_web|midi_stuff|gourlay_maxmeasures)',
                 sub, s)
    return s


@rule((2, 3, 25), 'petrucci_c1 -> petrucci-c1, 1style -> single-digit')
def conv(s):
    s = re.sub('petrucci_c1', 'petrucci-c1', s)
    s = re.sub('1style', 'single-digit', s)
    return s


@rule((2, 4, 0), _("bump version for release"))
def conv(s):
    return s


@rule((2, 5, 0), '\\quote -> \\quoteDuring')
def conv(s):
    s = re.sub(r'\\quote\s+"?([a-zA-Z0-9]+)"?\s+([0-9.*/]+)',
                 r'\\quoteDuring #"\1" { \\skip \2 }',
                 s)
    return s


@rule((2, 5, 1), 'ly:import-module -> ly:module-copy')
def conv(s):
    s = re.sub(r'ly:import-module',
                 r'ly:module-copy', s)
    return s


@rule((2, 5, 2), r'\markup .. < .. > .. -> \markup .. { .. } ..')
def conv(s):
    s = re.sub(r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
                 r'\\\1 {\2}', s)
    s = re.sub(r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
                 r'\\\1 {\2}', s)
    s = re.sub(r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
                 r'\\\1 {\2}', s)

    def get_markup(m):
        s = m.group(0)
        s = re.sub(r'''((\\"|})\s*){''', '\2 \\line {', s)
        return s
    s = re.sub(r'\\markup\s*{([^}]|{[^}]*})*}', get_markup, s)
    return s


@rule((2, 5, 3), 'ly:find-glyph-by-name -> ly:font-get-glyph, remove - from glyphnames.')
def conv(s):
    s = re.sub('ly:find-glyph-by-name', 'ly:font-get-glyph', s)
    s = re.sub('"(scripts|clefs|accidentals)-', r'"\1.', s)
    s = re.sub("'hufnagel-do-fa", "'hufnagel.do.fa", s)
    s = re.sub(
        "'(vaticana|hufnagel|medicaea|petrucci|neomensural|mensural)-", r"'\1.", s)
    return s


@rule((2, 5, 12), r'\set Slur #\'dashed = #X -> \slurDashed')
def conv(s):
    s = re.sub(r"\\override\s+(Voice\.)?Slur #'dashed\s*=\s*#\d*(\.\d+)?",
                 r"\\slurDashed", s)
    return s


@rule((2, 5, 13), _('\\encoding: smart recode latin1..utf-8. Remove ly:point-and-click'))
def conv(s):
    def func(match):
        encoding = match.group(1)

        if encoding == 'latin1':
            return match.group(2)

        stderr_write(NOT_SMART % ("\\encoding: %s" % encoding))
        stderr_write(_("LilyPond source must be UTF-8"))
        stderr_write('\n')
        if encoding == 'TeX':
            stderr_write(_("Try the texstrings backend"))
            stderr_write('\n')
        else:
            stderr_write(_("Do something like: %s") %
                         ("recode %s..utf-8 FILE" % encoding))
            stderr_write('\n')
        stderr_write(_("Or save as UTF-8 in your editor"))
        stderr_write('\n')
        raise FatalConversionError()

    s = re.sub(r'\\encoding\s+"?([a-zA-Z0-9]+)"?(\s+)', func, s)

    s = re.sub(r"#\(ly:set-point-and-click '[a-z-]+\)", '', s)
    return s


@rule((2, 5, 17), _('remove %s') % 'ly:stencil-set-extent!')
def conv(s):
    if re.search("ly:stencil-set-extent!", s):
        stderr_write(NOT_SMART % "ly:stencil-set-extent!")
        stderr_write(_('Use %s\n') %
                     '(set! VAR (ly:make-stencil (ly:stencil-expr VAR) X-EXT Y-EXT))')
        raise FatalConversionError()
    if re.search("ly:stencil-align-to!", s):
        stderr_write(NOT_SMART % "ly:stencil-align-to!")
        stderr_write(_('Use %s\n') %
                     '(set! VAR (ly:stencil-aligned-to VAR AXIS DIR))')
        raise FatalConversionError()
    return s


@rule((2, 5, 18), 'ly:warn -> ly:warning')
def conv(s):
    s = re.sub(r"ly:warn\b", 'ly:warning', s)
    return s


@rule((2, 5, 21), _('warn about auto beam settings'))
def conv(s):
    if re.search("(override-|revert-)auto-beam-setting", s)\
       or re.search("autoBeamSettings", s):
        stderr_write(NOT_SMART % _("auto beam settings"))
        stderr_write(_('''
Auto beam settings must now specify each interesting moment in a measure
explicitly; 1/4 is no longer multiplied to cover moments 1/2 and 3/4 too.
'''))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    return s


@rule((2, 5, 25), 'unfoldrepeats -> unfoldRepeats, compressmusic -> compressMusic')
def conv(s):
    s = re.sub(r"unfoldrepeats", 'unfoldRepeats', s)
    s = re.sub(r"compressmusic", 'compressMusic', s)
    return s


@rule((2, 6, 0), _("bump version for release"))
def conv(s):
    return s


@rule((2, 7, 0), 'ly:get-default-font -> ly:grob-default-font')
def conv(s):
    return re.sub('ly:get-default-font', 'ly:grob-default-font', s)


@rule((2, 7, 1), '''ly:parser-define -> ly:parser-define!
excentricity -> eccentricity
Timing_engraver -> Timing_translator + Default_bar_line_engraver
''')
def conv(s):
    s = re.sub('ly:parser-define', 'ly:parser-define!', s)
    s = re.sub('excentricity', 'eccentricity', s)
    s = re.sub(r'\\(consists|remove) *"?Timing_engraver"?',
                 r'\\\1 "Timing_translator" \\\1 "Default_bar_line_engraver"',
                 s)
    return s


@rule((2, 7, 2), 'ly:X-moment -> ly:moment-X')
def conv(s):
    s = re.sub('ly:(add|mul|mod|div)-moment', r'ly:moment-\1', s)
    return s


@rule((2, 7, 4), 'keyAccidentalOrder -> keyAlterationOrder')
def conv(s):
    s = re.sub('keyAccidentalOrder', 'keyAlterationOrder', s)
    return s


@rule((2, 7, 6), '''Performer_group_performer -> Performer_group, Engraver_group_engraver -> Engraver_group,
inside-slur -> avoid-slur''')
def conv(s):
    s = re.sub('Performer_group_performer', 'Performer_group', s)
    s = re.sub('Engraver_group_engraver', 'Engraver_group', s)
    s = re.sub(r"#'inside-slur\s*=\s*##t *",
                 r"#'avoid-slur = #'inside ", s)
    s = re.sub(r"#'inside-slur\s*=\s*##f *",
                 r"#'avoid-slur = #'around ", s)
    s = re.sub(r"#'inside-slur",
                 r"#'avoid-slur", s)
    return s


@rule((2, 7, 10), '\\applyxxx -> \\applyXxx')
def conv(s):
    s = re.sub(r'\\applyoutput', r'\\applyOutput', s)
    s = re.sub(r'\\applycontext', r'\\applyContext', s)
    s = re.sub(r'\\applymusic', r'\\applyMusic', s)
    s = re.sub(r'ly:grob-suicide', 'ly:grob-suicide!', s)
    return s


@rule((2, 7, 11), '"tabloid" -> "11x17"')
def conv(s):
    s = re.sub('"tabloid"', '"11x17"', s)
    return s


@rule((2, 7, 12), 'outputProperty -> overrideProperty')
def conv(s):
    s = re.sub(r'outputProperty', 'overrideProperty', s)
    return s


@rule((2, 7, 13), 'layout engine refactoring [FIXME]')
def conv(s):
    def subber(match):
        newkey = {'spacing-procedure': 'springs-and-rods',
                  'after-line-breaking-callback': 'after-line-breaking',
                  'before-line-breaking-callback': 'before-line-breaking',
                  'print-function': 'stencil'}[match.group(3)]
        what = match.group(1)
        grob = match.group(2)

        if what == 'revert':
            return "revert %s #'callbacks %% %s\n" % (grob, newkey)
        if what == 'override':
            return "override %s #'callbacks #'%s" % (grob, newkey)
        raise RuntimeError('1st group should match revert or override')

    s = re.sub(r"(override|revert)\s*([a-zA-Z.]+)\s*#'(spacing-procedure|after-line-breaking-callback"
                 + r"|before-line-breaking-callback|print-function)",
                 subber, s)

    if re.search('bar-size-procedure', s):
        stderr_write(NOT_SMART % "bar-size-procedure")
    if re.search('space-function', s):
        stderr_write(NOT_SMART % "space-function")
    if re.search('verticalAlignmentChildCallback', s):
        stderr_write(_('verticalAlignmentChildCallback has been deprecated'))
        stderr_write('\n')
    return s


@rule((2, 7, 14), _('Remove callbacks property, deprecate XY-extent-callback.'))
def conv(s):
    s = re.sub(r"\\override +([A-Z.a-z]+) #'callbacks",
                 r"\\override \1", s)
    s = re.sub(r"\\revert ([A-Z.a-z]+) #'callbacks % ([a-zA-Z]+)",
                 r"\\revert \1 #'\2", s)
    s = re.sub(r"([XY]-extent)-callback", r'\1', s)
    s = re.sub(r"RemoveEmptyVerticalGroup", "VerticalAxisGroup", s)
    s = re.sub(r"\\set ([a-zA-Z]*\.?)minimumVerticalExtent",
                 r"\\override \1VerticalAxisGroup #'minimum-Y-extent",
                 s)
    s = re.sub(r"minimumVerticalExtent",
                 r"\\override VerticalAxisGroup #'minimum-Y-extent",
                 s)
    s = re.sub(r"\\set ([a-zA-Z]*\.?)extraVerticalExtent",
                 r"\\override \1VerticalAxisGroup #'extra-Y-extent", s)
    s = re.sub(r"\\set ([a-zA-Z]*\.?)verticalExtent",
                 r"\\override \1VerticalAxisGroup #'Y-extent", s)
    return s


@rule((2, 7, 15), _('Use grob closures iso. XY-offset-callbacks.'))
def conv(s):
    if re.search('[XY]-offset-callbacks', s):
        stderr_write(NOT_SMART % "[XY]-offset-callbacks")
    if re.search('position-callbacks', s):
        stderr_write(NOT_SMART % "position-callbacks")
    return s


@rule((2, 7, 18), r"""bassFigureFormatFunction -> figuredBassFormatter
deprecate alignBassFigureAccidentals.
""")
def conv(s):
    s = re.sub('bassFigureFormatFunction', 'figuredBassFormatter', s)
    if re.search('alignBassFigureAccidentals', s):
        stderr_write(NOT_SMART % "alignBassFigureAccidentals")
    return s


@rule((2, 7, 22), r"\tag #'(a b) -> \tag #'a \tag #'b")
def conv(s):
    def sub_syms(m):
        syms = m.group(1).split()
        tags = ["\\tag #'%s" % s for s in syms]
        return ' '.join(tags)

    s = re.sub(r"\\tag #'\(([^)]+)\)", sub_syms, s)
    return s


@rule((2, 7, 24), _('deprecate %s') % 'number-visibility')
def conv(s):
    s = re.sub(r"#'number-visibility",
                 "#'number-visibility % number-visibility is deprecated. Tune the TupletNumber instead\n",
                 s)
    return s


@rule((2, 7, 28), "ly:spanner-get-bound -> ly:spanner-bound")
def conv(s):
    s = re.sub(r"ly:spanner-get-bound", "ly:spanner-bound", s)
    return s


@rule((2, 7, 29), "override Stem #'beamed-* -> #'details #'beamed-*")
def conv(s):
    for a in ['beamed-lengths', 'beamed-minimum-free-lengths',
              'lengths',
              'beamed-extreme-minimum-free-lengths']:
        s = re.sub(r"\\override\s+Stem\s+#'%s" % a,
                     r"\\override Stem #'details #'%s" % a,
                     s)
    return s


@rule((2, 7, 30), "\\epsfile")
def conv(s):
    s = re.sub(r'\\epsfile *#"', r'\\epsfile #X #10 #"', s)
    return s


@rule((2, 7, 31), "Foo_bar::bla_bla -> ly:foo-bar::bla-bla")
def conv(s):
    def sub_cxx_id(m):
        s = m.group(1)
        return 'ly:' + s.lower().replace('_', '-')

    s = re.sub(r'([A-Z][a-z_0-9]+::[a-z_0-9]+)',
                 sub_cxx_id, s)
    return s


@rule((2, 7, 32), _(r"foobar -> foo-bar for \paper, \layout"))
def conv(s):
    identifier_subs = [
        ('inputencoding', 'input-encoding'),
        ('printpagenumber', 'print-page-number'),
        ('outputscale', 'output-scale'),
        ('betweensystemspace', 'between-system-space'),
        ('betweensystempadding', 'between-system-padding'),
        ('pagetopspace', 'page-top-space'),
        ('raggedlastbottom', 'ragged-last-bottom'),
        ('raggedright', 'ragged-right'),
        ('raggedlast', 'ragged-last'),
        ('raggedbottom', 'ragged-bottom'),
        ('aftertitlespace', 'after-title-space'),
        ('beforetitlespace', 'before-title-space'),
        ('betweentitlespace', 'between-title-space'),
        ('topmargin', 'top-margin'),
        ('bottommargin', 'bottom-margin'),
        ('headsep', 'head-separation'),
        ('footsep', 'foot-separation'),
        ('rightmargin', 'right-margin'),
        ('leftmargin', 'left-margin'),
        ('printfirstpagenumber', 'print-first-page-number'),
        ('firstpagenumber', 'first-page-number'),
        ('hsize', 'paper-width'),
        ('vsize', 'paper-height'),
        ('horizontalshift', 'horizontal-shift'),
        ('staffspace', 'staff-space'),
        ('linethickness', 'line-thickness'),
        ('ledgerlinethickness', 'ledger-line-thickness'),
        ('blotdiameter', 'blot-diameter'),
        ('staffheight', 'staff-height'),
        ('linewidth', 'line-width'),
        ('annotatespacing', 'annotate-spacing')
    ]

    for (a, b) in identifier_subs:
        # for C++:
        # s = re.sub ('"%s"' % a, '"%s"' b, s)

        s = re.sub(a, b, s)
    return s


@rule((2, 7, 32), "debug-beam-quanting -> debug-beam-scoring")
def conv(s):
    s = re.sub('debug-beam-quanting', 'debug-beam-scoring', s)
    return s


@rule((2, 7, 36), "def-(music-function|markup-command) -> define-(music-function|markup-command)")
def conv(s):
    s = re.sub('def-music-function', 'define-music-function', s)
    s = re.sub('def-markup-command', 'define-markup-command', s)
    return s


@rule((2, 7, 40), "rehearsalMarkAlignSymbol/barNumberAlignSymbol -> break-align-symbol")
def conv(s):
    s = re.sub(r'\\set\s+Score\s*\.\s*barNumberAlignSymbol\s*=',
                 r"\\override Score.BarNumber #'break-align-symbol = ", s)
    s = re.sub(r'\\set\s*Score\s*\.\s*rehearsalMarkAlignSymbol\s*=',
                 r"\\override Score.RehearsalMark #'break-align-symbol = ", s)
    return s


@rule((2, 9, 4), "(page-)penalty -> (page-)break-penalty")
def conv(s):
    s = re.sub('page-penalty', 'page-break-penalty', s)
    s = re.sub('([^-])penalty', '\1break-penalty', s)
    return s


@rule((2, 9, 6), "\\context Foo \\applyOutput #bla -> \\applyOutput #'Foo #bla ")
def conv(s):
    s = re.sub(
        r'\\context\s+"?([a-zA-Z]+)"?\s*\\applyOutput', r"\\applyOutput #'\1", s)
    return s


@rule((2, 9, 9), "annotatefoo -> annotate-foo")
def conv(s):
    s = re.sub('annotatepage', 'annotate-page', s)
    s = re.sub('annotateheaders', 'annotate-headers', s)
    s = re.sub('annotatesystems', 'annotate-systems', s)
    return s


@rule((2, 9, 11), "\\set tupletNumberFormatFunction -> \\override #'text = ")
def conv(s):
    s = re.sub(r"""(\\set\s)?(?P<context>[a-zA-Z]*.?)tupletNumberFormatFunction\s*=\s*#denominator-tuplet-formatter""",
                 r"""\\override \g<context>TupletNumber #'text = #tuplet-number::calc-denominator-text""", s)

    s = re.sub(r"""(\\set\s+)?(?P<context>[a-zA-Z]*.?)tupletNumberFormatFunction\s*=\s*#fraction-tuplet-formatter""",
                 r"""\\override \g<context>TupletNumber #'text = #tuplet-number::calc-fraction-text""", s)

    if re.search('tupletNumberFormatFunction', s):
        stderr_write("\n")
        stderr_write(
            "tupletNumberFormatFunction has been removed. Use #'text property on TupletNumber")
        stderr_write("\n")
    return s


@rule((2, 9, 13), "instrument -> instrumentName, instr -> shortInstrumentName, vocNam -> shortVocalName")
def conv(s):
    s = re.sub('vocNam', 'shortVocalName', s)
    s = re.sub(r'\.instr\s*=', r'.shortInstrumentName =', s)
    s = re.sub(r'\.instrument\s*=', r'.instrumentName =', s)
    return s


@rule((2, 9, 16), _("deprecate \\tempo in \\midi"))
def conv(s):

    def sub_tempo(m):
        dur = int(m.group(1))
        dots = len(m.group(2))
        count = int(m.group(3))

        log2 = 0
        while dur > 1:
            dur /= 2
            log2 += 1

        den = (1 << dots) * (1 << log2)
        num = ((1 << (dots+1)) - 1)

        return r"""
  \midi {
    \context {
      \Score
      tempoWholesPerMinute = #(ly:make-moment %d %d)
      }
    }

""" % (num*count, den)

    s = re.sub(
        r'\\midi\s*{\s*\\tempo ([0-9]+)\s*([.]*)\s*=\s*([0-9]+)\s*}', sub_tempo, s)
    return s


@rule((2, 9, 19), "printfirst-page-number -> print-first-page-number")
def conv(s):
    s = re.sub('printfirst-page-number', 'print-first-page-number', s)
    return s


@rule((2, 10, 0), _("bump version for release"))
def conv(s):
    return s


@rule((2, 11, 2), "ly:clone-parser -> ly:parser-clone")
def conv(s):
    return re.sub('ly:clone-parser',
                  'ly:parser-clone', s)


@rule((2, 11, 3), "no-spacing-rods -> extra-spacing-width")
def conv(s):
    s = re.sub(r"no-spacing-rods\s+=\s+##t",
                 r"extra-spacing-width = #'(+inf.0 . -inf.0)", s)
    s = re.sub(r"no-spacing-rods\s+=\s+##f",
                 r"extra-spacing-width = #'(0 . 0)", s)
    return s


@rule((2, 11, 5), _("deprecate cautionary-style. Use AccidentalCautionary properties"))
def conv(s):
    s = re.sub(r"Accidental\s*#'cautionary-style\s*=\s*#'smaller",
                 "AccidentalCautionary #'font-size = #-2", s)
    s = re.sub(r"Accidental\s*#'cautionary-style\s*=\s*#'parentheses",
                 "AccidentalCautionary #'parenthesized = ##t", s)
    s = re.sub(r"([A-Za-z]+)\s*#'cautionary-style\s*=\s*#'parentheses",
                 r"\1 #'parenthesized = ##t", s)
    s = re.sub(r"([A-Za-z]+)\s*#'cautionary-style\s*=\s*#'smaller",
                 r"\1 #'font-size = #-2", s)
    return s


@rule((2, 11, 6), _("Rename accidental glyphs, use glyph-name-alist."))
def conv(s):

    def sub_acc_name(m):
        idx = int(m.group(1).replace('M', '-'))

        return ["accidentals.doublesharp",
                "accidentals.sharp.slashslash.stemstemstem",
                "accidentals.sharp",
                "accidentals.sharp.slashslash.stem",
                "accidentals.natural",
                "accidentals.mirroredflat",
                "accidentals.flat",
                "accidentals.mirroredflat.flat",
                "accidentals.flatflat"][4-idx]

    s = re.sub(r"accidentals[.](M?[-0-9]+)",
                 sub_acc_name, s)
    s = re.sub(r"(KeySignature|Accidental[A-Za-z]*)\s*#'style\s*=\s*#'([a-z]+)",
                 r"\1 #'glyph-name-alist = #alteration-\2-glyph-name-alist", s)
    # FIXME: standard vs default, alteration-FOO vs FOO-alteration
    s = s.replace('alteration-default-glyph-name-alist',
                      'standard-alteration-glyph-name-alist')
    return s


@rule((2, 11, 10), """allowBeamBreak -> Beam #'breakable = ##t
addquote -> addQuote
""")
def conv(s):
    s = re.sub(r'(\\set\s+)?([A-Z][a-zA-Z]+\s*\.\s*)allowBeamBreak',
                 r"\\override \2Beam #'breakable", s)
    s = re.sub(r'(\\set\s+)?allowBeamBreak',
                 r"\\override Beam #'breakable", s)
    s = re.sub(r'addquote', 'addQuote', s)
    if re.search("Span_dynamic_performer", s):
        stderr_write(
            "Span_dynamic_performer has been merged into Dynamic_performer")

    return s


@rule((2, 11, 11), "layout-set-staff-size -> layout-set-absolute-staff-size")
def conv(s):
    s = re.sub(r'\(layout-set-staff-size \(\*\s*([0-9.]+)\s*(pt|mm|cm)\)\)',
                 r'(layout-set-absolute-staff-size (* \1 \2))', s)
    return s


@rule((2, 11, 13), "#'arrow = ##t -> #'bound-details #'right #'arrow = ##t")
def conv(s):
    s = re.sub(r"\\override\s*([a-zA-Z.]+)\s*#'arrow\s*=\s*##t",
                 r"\\override \1 #'bound-details #'right #'arrow = ##t",
                 s)

    if re.search('edge-text', s):
        stderr_write(NOT_SMART % _("edge-text settings for TextSpanner"))
        stderr_write(_("Use\n\n%s") %
                     "\t\\override TextSpanner #'bound-details #'right #'text = <right-text>\n"
                     "\t\\override TextSpanner #'bound-details #'left #'text = <left-text>\n")
    return s


@rule((2, 11, 15), "TextSpanner #'edge-height -> #'bound-details #'right/left #'text = ...\n\
Remove 'forced-distance for fixed spacing between staves in a PianoStaff.")
def conv(s):
    def sub_edge_height(m):
        s = ''
        for (var, h) in [('left', m.group(3)),
                         ('right', m.group(4))]:

            if h and float(h):
                once = m.group(1)
                if not once:
                    once = ''
                context = m.group(2)
                if not context:
                    context = ''

                s += (r"%s \override %sTextSpanner #'bound-details #'%s #'text = \markup { \draw-line #'(0 . %s) }"
                      % (once, context, var, h))

                s += '\n'

        return s

    s = re.sub(
        r"(\\once)?\s*\\override\s*([a-zA-Z]+\s*[.]\s*)?TextSpanner\s*#'edge-height\s*=\s*#'\(\s*([0-9.-]+)\s+[.]\s+([0-9.-]+)\s*\)", sub_edge_height, s)
    if re.search(r"#'forced-distance", s):
        stderr_write(NOT_SMART % "VerticalAlignment #'forced-distance")
        stderr_write(_("Use the `alignment-offsets' sub-property of\n"))
        stderr_write(_("NonMusicalPaperColumn #'line-break-system-details\n"))
        stderr_write(_("to set fixed distances between staves.\n"))
    return s


@rule((2, 11, 23), "#'break-align-symbol -> #'break-align-symbols")
def conv(s):
    s = re.sub(r"\\override\s*([a-zA-Z.]+)\s*#'break-align-symbol\s*=\s*#'([a-z-]+)",
                 r"\\override \1 #'break-align-symbols = #'(\2)", s)
    return s


@rule((2, 11, 35), """scripts.caesura -> scripts.caesura.curved.
""" + _("Use #'style not #'dash-fraction to select solid/dashed lines."))
def conv(s):
    s = re.sub(r"scripts\.caesura",
                 r"scripts.caesura.curved", s)

    if re.search('dash-fraction', s):
        stderr_write(NOT_SMART % _("all settings related to dashed lines"))
        stderr_write(
            _("Use \\override ... #'style = #'line for solid lines and\n"))
        stderr_write(
            _("\t\\override ... #'style = #'dashed-line for dashed lines."))
    return s


@rule((2, 11, 38), """\\setEasyHeads -> \\easyHeadsOn, \\fatText -> \\textLengthOn,
\\emptyText -> \\textLengthOff""")
def conv(s):
    s = re.sub(r"setEasyHeads", r"easyHeadsOn", s)
    s = re.sub(r"fatText", r"textLengthOn", s)
    s = re.sub(r"emptyText", r"textLengthOff", s)
    return s


@rule((2, 11, 46), "\\set hairpinToBarline -> \\override Hairpin #'to-barline")
def conv(s):
    s = re.sub(r"\\set\s+([a-zA-Z]+)\s*.\s*hairpinToBarline\s*=\s*##([tf]+)",
                 r"\\override \1.Hairpin #'to-barline = ##\2", s)
    s = re.sub(r"\\set\s+hairpinToBarline\s*=\s*##([tf]+)",
                 r"\\override Hairpin #'to-barline = ##\1", s)
    s = re.sub(r"\\unset\s+([a-zA-Z]+)\s*.\s*hairpinToBarline",
                 r"\\revert \1.Hairpin #'to-barline", s)
    s = re.sub(r"\\unset\s+hairpinToBarline",
                 r"\\revert Hairpin #'to-barline", s)
    s = re.sub(r"hairpinToBarline\s*=\s*##([tf]+)",
                 r"\\override Hairpin #'to-barline = ##\1", s)
    s = re.sub(r"\\set (de|)crescendoSpanner = #'dashed-line",
                 r"\\set \1crescendoSpanner = #'text", s)
    return s


@rule((2, 11, 48), "\\compressMusic -> \\scaleDurations")
def conv(s):
    s = re.sub(r"compressMusic", r"scaleDurations", s)
    return s


@rule((2, 11, 50), _("metronomeMarkFormatter uses text markup as second argument,\n\
fret diagram properties moved to fret-diagram-details."))
def conv(s):
    # warning 1/2: metronomeMarkFormatter uses text markup as second argument
    if re.search('metronomeMarkFormatter', s):
        stderr_write(NOT_SMART % "metronomeMarkFormatter")
        stderr_write(
            _("metronomeMarkFormatter got an additional text argument.\n"))
        stderr_write(_("The function assigned to Score.metronomeMarkFunction now uses the signature\n%s") %
                     "\t(format-metronome-markup text dur count context)\n")

    # warning 2/2: fret diagram properties moved to fret-diagram-details
    fret_props = ['barre-type',
                  'dot-color',
                  'dot-radius',
                  'finger-code',
                  'fret-count',
                  'label-dir',
                  'number-type',
                  'string-count',
                  'xo-font-magnification',
                  'mute-string',
                  'open-string',
                  'orientation']
    for prop in fret_props:
        if re.search(prop, s):
            stderr_write(NOT_SMART %
                         (_("%s in fret-diagram properties") % prop))
            stderr_write(_('Use %s\n') % "fret-diagram-details")
    return s


@rule((2, 11, 51), "\\octave -> \\octaveCheck, \\arpeggioUp -> \\arpeggioArrowUp,\n\
\\arpeggioDown -> \\arpeggioArrowDown, \\arpeggioNeutral -> \\arpeggioNormal,\n\
\\setTextCresc -> \\crescTextCresc, \\setTextDecresc -> \\dimTextDecresc,\n\
\\setTextDecr -> \\dimTextDecr, \\setTextDim -> \\dimTextDim,\n\
\\setHairpinCresc -> \\crescHairpin, \\setHairpinDecresc -> \\dimHairpin,\n\
\\sustainUp -> \\sustainOff, \\sustainDown -> \\sustainOn\n\
\\sostenutoDown -> \\sostenutoOn, \\sostenutoUp -> \\sostenutoOff")
def conv(s):
    s = re.sub(r"\\octave(?![a-zA-Z])", r"\\octaveCheck", s)
    s = re.sub(r"arpeggioUp", r"arpeggioArrowUp", s)
    s = re.sub(r"arpeggioDown", r"arpeggioArrowDown", s)
    s = re.sub(r"arpeggioNeutral", r"arpeggioNormal", s)
    s = re.sub(r"setTextCresc", r"crescTextCresc", s)
    s = re.sub(r"setTextDecresc", r"dimTextDecresc", s)
    s = re.sub(r"setTextDecr", r"dimTextDecr", s)
    s = re.sub(r"setTextDim", r"dimTextDim", s)
    s = re.sub(r"setHairpinCresc", r"crescHairpin", s)
    s = re.sub(r"setHairpinDecresc", r"dimHairpin", s)
    s = re.sub(r"sustainUp", r"sustainOff", s)
    s = re.sub(r"sustainDown", r"sustainOn", s)
    s = re.sub(r"sostenutoDown", r"sostenutoOn", s)
    s = re.sub(r"sostenutoUp", r"sostenutoOff", s)
    return s


@rule((2, 11, 52), "\\setHairpinDim -> \\dimHairpin")
def conv(s):
    s = s.replace("setHairpinDim", "dimHairpin")
    return s


@rule((2, 11, 53), "infinite-spacing-height -> extra-spacing-height")
def conv(s):
    s = re.sub(r"infinite-spacing-height\s+=\s+##t",
                 r"extra-spacing-height = #'(-inf.0 . +inf.0)", s)
    s = re.sub(r"infinite-spacing-height\s+=\s+##f",
                 r"extra-spacing-height = #'(0 . 0)", s)
    return s


@rule((2, 11, 55), "#(set-octavation oct) -> \\ottava #oct,\n\
\\put-adjacent markup axis dir markup -> \\put-adjacent axis dir markup markup")
def conv(s):
    s = re.sub(r"#\(set-octavation (-*[0-9]+)\)", r"\\ottava #\1", s)
    if re.search('put-adjacent', s):
        stderr_write(NOT_SMART % _("\\put-adjacent argument order"))
        stderr_write(_("Axis and direction now come before markups:\n"))
        stderr_write(_("\\put-adjacent axis dir markup markup."))
        stderr_write("\n")
    return s


@rule((2, 11, 57), "\\center-align -> \\center-column, \\hcenter -> \\center-align")
def conv(s):
    s = re.sub(r"([\\:]+)center-align", r"\1center-column", s)
    s = re.sub(r"hcenter(\s+)", r"center-align\1", s)
    return s


@rule((2, 11, 60), "printallheaders -> print-all-headers")
def conv(s):
    s = re.sub(r"printallheaders", r"print-all-headers", s)
    return s


@rule((2, 11, 61), "gregorian-init.ly -> gregorian.ly")
def conv(s):
    s = re.sub(r'\\include(\s+)"gregorian-init.ly"',
                 r'\\include\1"gregorian.ly"', s)
    return s


@rule((2, 11, 62), "makam-init.ly -> makam.ly, \\bigger -> \\larger")
def conv(s):
    s = re.sub(r'\\include(\s+)"makam-init.ly"',
                 r'\\include\1"makam.ly"', s)
    s = re.sub(r"([\\:])bigger", r"\1larger", s)
    return s


@rule((2, 11, 64), "systemSeparatorMarkup -> system-separator-markup,\n\
InnerStaffGroup -> StaffGroup, InnerChoirStaff -> ChoirStaff")
def conv(s):
    s = re.sub(r'systemSeparatorMarkup', r'system-separator-markup', s)
    if re.search(r'\\InnerStaffGroup', s):
        stderr_write(NOT_SMART % _("re-definition of InnerStaffGroup"))
        stderr_write(FROM_TO % ("InnerStaffGroup", "StaffGroup"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    if re.search(r'\\InnerChoirStaff', s):
        stderr_write(NOT_SMART % _("re-definition of InnerChoirStaff"))
        stderr_write(FROM_TO % ("InnerChoirStaff", "ChoirStaff"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()

    s = re.sub('InnerStaffGroup', 'StaffGroup', s)
    s = re.sub('InnerChoirStaff', 'ChoirStaff', s)
    return s


@rule((2, 12, 0),
      _("Syntax changes for \\addChordShape and \\chord-shape") + "\n" +
      _("bump version for release"))
def conv(s):
    if re.search(r'\\addChordShape', s):
        stderr_write(NOT_SMART % "addChordShape")
        stderr_write(_("stringTuning must be added to addChordShape call.\n"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    if re.search(r'\\chord-shape', s):
        stderr_write(NOT_SMART % "chord-shape")
        stderr_write(_("stringTuning must be added to chord-shape call.\n"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    return s


@rule((2, 12, 3),
      _("Remove oldaddlyrics"))
def conv(s):
    if re.search(r'\\oldaddlyrics', s):
        stderr_write(NOT_SMART % "oldaddlyrics")
        stderr_write(_("oldaddlyrics is no longer supported. \n \
        Use addlyrics or lyricsto instead.\n"))
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    return s


@rule((2, 13, 0), _("keySignature property not reversed any more\n\
MIDI 47: orchestral strings -> orchestral harp"))
def conv(s):
    if re.search(r'\set Staff.keySignature', s):
        stderr_write(NOT_SMART % "Staff.keySignature")
        stderr_write(_("The alist for Staff.keySignature is no \
longer in reversed order.\n"))
    s = s.replace('"orchestral strings"', '"orchestral harp"')
    return s


@rule((2, 13, 1),
      _("\\bar \".\" now produces a thick barline\n\
ly:hairpin::after-line-breaking -> ly:spanner::kill-zero-spanned-time\n\
Dash parameters for slurs and ties are now in dash-definition"))
def conv(s):
    if re.search(r'\\bar\s*"\."', s):
        stderr_write(NOT_SMART % "\\bar \".\"")
        stderr_write(_("\\bar \".\" now produces a thick barline.\n"))
        stderr_write(UPDATE_MANUALLY)
    s = re.sub(r'ly:hairpin::after-line-breaking',
                 r'ly:spanner::kill-zero-spanned-time', s)
    if re.search(r"(Slur|Tie)\w+#'dash-fraction", s) \
            or re.search(r"(Slur|Tie)\w+#'dash-period", s):
        stderr_write(NOT_SMART % "dash-fraction, dash-period")
        stderr_write(
            _("Dash parameters for slurs and ties are now in \'dash-definition.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 13, 4),
      _("Autobeaming rules have changed.  override-auto-beam-setting and\n\
revert-auto-beam-setting have been eliminated.\n\
\\overrideBeamSettings has been added.\n\
beatGrouping has been eliminated.\n\
Different settings for vertical layout.\n\
ly:system-start-text::print -> system-start-text::print\n\
Beam #'thickness -> Beam #'beam-thickness\n\
ly:note-head::brew-ez-stencil -> note-head::brew-ez-stencil\n\
ly:ambitus::print -> ambitus::print\n\
Explicit dynamics context definition from `Piano centered dynamics'\n\
template replaced by new `Dynamics' context."))
def conv(s):
    if re.search("override-auto-beam-setting", s):
        stderr_write(NOT_SMART % "override-auto-beam-setting")
        stderr_write(_(" \
   Autobeam settings are now overriden with \\overrideBeamSettings.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search("revert-auto-beam-setting", s):
        stderr_write(NOT_SMART % "override-auto-beam-setting")
        stderr_write(_(" \
   Autobeam settings are now reverted with \\revertBeamSettings.\n"))
        stderr_write(UPDATE_MANUALLY)
    s = re.sub(r"\\set\s+beatGrouping", r"\\setBeatGrouping", s)
    if re.search(r"\w+\s*.\s*beatGrouping", s):
        stderr_write(NOT_SMART % "beatGrouping")
        stderr_write(_(" \
   beatGrouping with a specified context must now be accomplished with\n\
   \\overrideBeamSettings.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'alignment-offsets', s):
        stderr_write(NOT_SMART % "alignment-offsets")
        stderr_write(_("alignment-offsets has been changed to alignment-distances: \
you must now specify the distances between staves rather than the offset of staves.\n"))
        stderr_write(UPDATE_MANUALLY)
    s = re.sub('ly:(system-start-text::print|note-head::brew-ez-stencil|ambitus::print)',
                 '\\1', s)
    s = re.sub('(\\bBeam\\s+#\')(?=thickness\\b)', '\\1beam-', s)
    s = re.sub(r'(\\context\s*\{{1}[^\}]+\\type\s+"?Engraver_group"?\s+\\name\s+"*Dynamics"*[^\}]*\}{1})',
                 '% [Convert-ly] The Dynamics context is now included by default.', s)
    return s


@rule((2, 13, 10),
      _("Remove obsolete engravers/translators: Note_swallow_translator,\n\
Rest_swallow_translator, Skip_event_swallow_translator, Swallow_engraver,\n\
Swallow_performer and String_number_engraver.\n\
New vertical spacing variables."))
def conv(s):
    s = re.sub(r'\\(consists|remove)\s+"*(Swallow_(engraver|performer)|'
                 '(Note|Rest|Skip_event)_swallow_translator|String_number_engraver)"*',
                 '', s)

    # match through the end of assignments in the form "x = 30", "x = 1 \in", or "x = #3"
    s = re.sub(r"(page-top-space)\s*=\s*(([+-]?[.\d]*\s*\\[-\w]+)|(#?\s*[-+]?[.\d]+))",
                 r"obsolete-\g<0>"
                 r"  top-system-spacing #'space = #(/ obsolete-\1 staff-space)",
                 s)
    s = re.sub(r"(between-system-space)\s*=\s*(([+-]?[.\d]*\s*\\[-\w]+)|(#?\s*[-+]?[.\d]+))",
                 r"obsolete-\g<0>"
                 r"  between-system-spacing #'space = #(/ obsolete-\1 staff-space)"
                 r"  between-scores-system-spacing #'space = #(/ obsolete-\1 staff-space)",
                 s)
    s = re.sub(r"(between-system-padding)\s*=\s*(([+-]?[.\d]*\s*\\[-\w]+)|(#?\s*[-+]?[.\d]+))",
                 r"obsolete-\g<0>"
                 r"  between-system-spacing #'padding = #(/ obsolete-\1 staff-space)"
                 r"  between-scores-system-spacing #'padding = #(/ obsolete-\1 staff-space)",
                 s)
    s = re.sub(r"((before|between|after)-title-space)\s*=\s*(([+-]?[.\d]*\s*\\[-\w]+)|(#?\s*[-+]?[.\d]+))",
                 r"obsolete-\g<0>"
                 r"  \2-title-spacing #'space = #(/ obsolete-\1 staff-space)",
                 s)

    if re.search(r"VerticalAxisGroup\s*#\s*'minimum-Y-extent", s):
        stderr_write(NOT_SMART % "minimum-Y-extent")
        stderr_write(
            _("Vertical spacing no longer depends on the Y-extent of a VerticalAxisGroup.\n"))
        stderr_write(UPDATE_MANUALLY)

    return s


@rule((2, 13, 16),
      _("Unify fetaNumber and fetaDynamic encodings"))
def conv(s):
    return re.sub(r'\bfeta(Number|Dynamic)', 'fetaText', s)


@rule((2, 13, 18),
      _("\\RemoveEmpty*StaffContext -> \\*Staff \\RemoveEmptyStaves"))
def conv(s):
    s = re.sub(r"\\RemoveEmpty(|Drum|Rhythmic|Tab)StaffContext",
                 r"\\\1Staff \\RemoveEmptyStaves",
                 s)
    s = re.sub(r"\\AncientRemoveEmptyStaffContext",
                 r"\\VaticanaStaff \\RemoveEmptyStaves",
                 s)
    return s


@rule((2, 13, 20),
      _("\\cresc etc. are now postfix operators"))
def conv(s):
    s = re.sub(r'\\(cresc|dim|endcresc|enddim)\b', r'\\deprecated\1', s)
    return s


@rule((2, 13, 27),
      ("interval-translate -> coord-translate"))
def conv(s):
    s = re.sub('interval-translate', 'coord-translate', s)
    return s


@rule((2, 13, 29),
      _("Eliminate beamSettings, beatLength, \\setBeatGrouping, \\overrideBeamSettings and \\revertBeamSettings.\n\
\"accordion.accEtcbase\" -> \"accordion.etcbass\""))
def conv(s):
    def sub_acc(m):
        d = {
            'Dot': 'dot',
            'Discant': 'discant',
            'Bayanbase': 'bayanbass',
            'Stdbase': 'stdbass',
            'Freebase': 'freebass',
            'OldEE': 'oldEE'
        }
        return '"accordion.%s"' % d[m.group(1)]

    s = re.sub(r'"accordion\.acc([a-zA-Z]+)"',
                 sub_acc, s)
    if re.search(r'overrideBeamSettings', s):
        stderr_write(NOT_SMART % "\\overrideBeamSettings")
        stderr_write(
            _("Use \\set beamExceptions or \\overrideTimeSignatureSettings.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'revertBeamSettings', s):
        stderr_write(NOT_SMART % "\\revertBeamSettings")
        stderr_write(
            _("Use \\set beamExceptions or \\revertTimeSignatureSettings.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'beamSettings', s):
        stderr_write(NOT_SMART % "beamSettings")
        stderr_write(_("Use baseMoment, beatStructure, and beamExceptions.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'beatLength', s):
        stderr_write(NOT_SMART % "beatLength")
        stderr_write(_("Use baseMoment and beatStructure.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'setBeatGrouping', s):
        stderr_write(NOT_SMART % "setbeatGrouping")
        stderr_write(_("Use baseMoment and beatStructure.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 13, 31),
      _("Woodwind diagrams: Move size, thickness, and graphic from argument list to properties.\n\
Deprecate negative dash-period for hidden lines: use #'style = #'none instead."))
def conv(s):
    if re.search(r'woodwind-diagram', s):
        stderr_write(NOT_SMART % "woodwind-diagrams")
        stderr_write(
            _("Move size, thickness, and graphic to properties.  Argument should be just the key list.\n"))
        stderr_write(UPDATE_MANUALLY)
    s = re.sub(r"dash-period\s+=\s*#\s*-[0-9.]+",
                 r"style = #'none",
                 s)
    return s


@rule((2, 13, 36),
      _("Rename vertical spacing variables.\n\
Add fretboard-table argument to savePredefinedFretboard."))
def conv(s):
    s = re.sub('after-title-spacing',           'markup-system-spacing', s)
    s = re.sub('before-title-spacing',          'score-markup-spacing',  s)
    s = re.sub('between-scores-system-spacing', 'score-system-spacing',  s)
    # this rule also converts page-breaking-between-system-spacing:
    s = re.sub('between-system-spacing',        'system-system-spacing', s)
    s = re.sub('between-title-spacing',         'markup-markup-spacing', s)
    s = re.sub('bottom-system-spacing',         'last-bottom-spacing',   s)
    s = re.sub('top-title-spacing',             'top-markup-spacing',    s)

    s = re.sub(r"storePredefinedDiagram",
                 r"storePredefinedDiagram #default-fret-table",
                 s)
    return s


@rule((2, 13, 39),
      _("Rename vertical spacing grob properties."))
def conv(s):
    # this rule also converts default-next-staff-spacing:
    s = re.sub('next-staff-spacing',
                 'staff-staff-spacing',             s)
    # this is not a mistake:
    #   Both 'next- and 'between- become 'staff-staff-spacing.
    #   There is no conflict since they are in different grobs.
    s = re.sub('between-staff-spacing',
                 'staff-staff-spacing',             s)
    s = re.sub('after-last-staff-spacing',
                 'staffgroup-staff-spacing',        s)
    s = re.sub('inter-staff-spacing',
                 'nonstaff-relatedstaff-spacing',   s)
    s = re.sub('non-affinity-spacing',
                 'nonstaff-unrelatedstaff-spacing', s)
    s = re.sub('inter-loose-line-spacing',
                 'nonstaff-nonstaff-spacing',       s)

    return s


@rule((2, 13, 40),
      _("Remove \\paper variables head-separation and foot-separation."))
def conv(s):
    if re.search(r'head-separation', s):
        stderr_write(NOT_SMART % "head-separation")
        stderr_write(_("Adjust settings for top-system-spacing instead.\n"))
        stderr_write(UPDATE_MANUALLY)
    if re.search(r'foot-separation', s):
        stderr_write(NOT_SMART % "foot-separation")
        stderr_write(_("Adjust settings for last-bottom-spacing instead.\n"))
        stderr_write(UPDATE_MANUALLY)

    return s


@rule((2, 13, 42),
      _("Rename space to basic-distance in various spacing alists.\n\
Remove HarmonicParenthesesItem grob."))
def conv(s):
    s = re.sub(
        r'\(space\s+\.\s+([0-9]*\.?[0-9]*)\)', r'(basic-distance . \1)', s)
    s = re.sub(r"#'space\s+=\s+#?([0-9]*\.?[0-9]*)",
                 r"#'basic-distance = #\1", s)
    if re.search(r'HarmonicParenthesesItem', s):
        stderr_write(NOT_SMART % "HarmonicParenthesesItem")
        stderr_write(_("HarmonicParenthesesItem has been eliminated.\n"))
        stderr_write(
            _("Harmonic parentheses are part of the TabNoteHead grob.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 13, 44),
      _("Remove context from overrideTimeSignatureSettings and revertTimeSignatureSettings.\n"))
def conv(s):
    s = re.sub(
        r"\\(override|revert)TimeSignatureSettings(\s+[^#]*)(#[^#]*)#", r"\\\1TimeSignatureSettings\2#", s)
    return s


@rule((2, 13, 46),
      _("Change stringTunings from a list of semitones to a list of pitches.\n"
          "Change tenor and baritone ukulele names in string tunings.\n"
          "Generate messages for manual conversion of vertical spacing if required."))
def conv(s):
    def semitones2pitch(semitones):
        steps = [0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6]
        alterations = ["NATURAL", "SHARP", "NATURAL", "SHARP", "NATURAL",
                       "NATURAL", "SHARP", "NATURAL", "SHARP", "NATURAL", "SHARP", "NATURAL"]
        octave = 0
        while semitones > 11:
            octave += 1
            semitones -= 12
        while semitones < 0:
            octave -= 1
            semitones += 12
        pitchArgs = "%d %d %s" % (
            octave, steps[semitones], alterations[semitones])
        return pitchArgs

    def convert_tones(semitone_list):
        tones = semitone_list.split()
        res = ""
        for tone in tones:
            args = semitones2pitch(int(tone))
            res += ",(ly:make-pitch " + args + ") "
        return res

    def new_tunings(matchobj):
        return "stringTunings = #`(" + convert_tones(matchobj.group(1)) + ")"
    s = re.sub(r"stringTunings\s*=\s*#'\(([\d\s-]*)\)",
                 new_tunings, s)

    s = re.sub(r"ukulele-(tenor|baritone)-tuning", r"\1-ukulele-tuning", s)

    if re.search(r"[^-]page-top-space", s):
        stderr_write(NOT_SMART % "page-top-space")
        stderr_write(UPDATE_MANUALLY)
    if re.search(r"[^-]between-system-(space|padding)", s):
        stderr_write(NOT_SMART % "between-system-space, -padding")
        stderr_write(UPDATE_MANUALLY)
    if re.search(r"[^-](before|between|after)-title-space", s):
        stderr_write(NOT_SMART % "before-, between-, after-title-space")
        stderr_write(UPDATE_MANUALLY)
    if re.search(r"\\name\s", s):
        stderr_write(
            "\n" + _("Vertical spacing changes might affect user-defined contexts.") + "\n")
        stderr_write(UPDATE_MANUALLY)

    return s


@rule((2, 13, 48),
      _("Replace bar-size with bar-extent."))
def conv(s):
    def size_as_extent(matchobj):
        half = "%g" % (float(matchobj.group(1)) / 2)
        return "bar-extent = #'(-" + half + " . " + half + ")"

    s = re.sub(r"bar-size\s*=\s*#([0-9\.]+)", size_as_extent, s)

    return s


@rule((2, 13, 51),
      _("Woodwind diagrams: Changes to the clarinet diagram."))
def conv(s):
    if re.search(r'\\woodwind-diagram\s*#[^#]*clarinet\s', s):
        stderr_write(NOT_SMART % "woodwind-diagrams")
        stderr_write(
            _("Clarinet fingering changed to reflect actual anatomy of instrument.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 14, 0),
      _("bump version for release"))
def conv(s):
    return s


@rule((2, 15, 7),
      _("Handling of non-automatic footnotes."))
def conv(s):
    if re.search(r'\\footnote', s):
        stderr_write(NOT_SMART % "\\footnote")
        stderr_write(
            _("If you are using non-automatic footnotes, make sure to set footnote-auto-numbering = ##f in the paper block.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 15, 9),
      _("Change in internal property for MultiMeasureRest"))
def conv(s):
    if re.search(r'use-breve-rest', s):
        stderr_write(NOT_SMART % "use-breve-rest")
        stderr_write(
            _("This internal property has been replaced by round-up-to-longer-rest, round-up-exceptions and usable-duration-logs.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 15, 10),
      _("Creation of a Flag grob and moving of certain Stem properties to this grob"))
def conv(s):
    s = re.sub(r"Stem\s+#'flag-style", r"Flag #'style", s)
    s = re.sub(r"Stem\s+#'stroke-style", r"Flag #'stroke-style", s)
    s = re.sub(r"Stem\s+#'flag", r"Flag #'stencil", s)
    s = re.sub(r"(\s+(?:\\once\s*)?)\\override\s+Stem\s+#'transparent\s*=\s*##t",
                 r"\g<1>\\override Stem #'transparent = ##t\g<1>\\override Flag #'transparent = ##t", s)
    s = re.sub(r"(\s+(?:\\once\s*)?)\\revert\s*Stem\s+#'transparent",
                 r"\g<1>\\revert Stem #'transparent\g<1>\\revert Flag #'transparent", s)
    s = re.sub(r"(\s+(?:\\once\s*)?)\\override\s+Stem\s+#'stencil\s*=\s*##f",
                 r"\g<1>\\override Stem #'stencil = ##f\g<1>\\override Flag #'stencil = ##f", s)
    s = re.sub(r"(\s+(?:\\once\s*)?)\\revert\s*Stem\s+#'stencil",
                 r"\g<1>\\revert Stem #'stencil\g<1>\\revert Flag #'stencil", s)
    return s


@rule((2, 15, 16), r"\makeStringTuning, \contextStringTuning -> \stringTuning")
def conv(s):
    s = re.sub(r"(\s+)\\contextStringTuning(\s+)#'([-a-zA-Z]+)(\s+<[^<>]+>)",
                 r"""\g<1>#(define \g<3> #{ \\stringTuning\g<4> #})\g<1>\\set stringTunings = #\g<3>""",
                 s)
    s = re.sub(r"""
\\makeStringTuning(\s+)#'([-a-zA-Z]+)""",
                 r"""
"\g<2>" = \\stringTuning""", s)
    s = re.sub(r"\\makeStringTuning(\s+)#'([-a-zA-Z]+)(\s+<[^<>]+>)",
                 r"#(define \g<2> #{ \\stringTuning\g<3> #})", s)
    return s


@rule((2, 15, 17), "\\markuplines -> \\markuplist\n\
Change Beam broken slope syntax.")
def conv(s):
    s = re.sub(r"""
\\markuplines( +)([^ ].*)
            \1([^ ])""", r"""
\\markuplist\g<1>\g<2>
           \g<1>\g<3>""", s)
    s = re.sub(r"\\markuplines", r"\\markuplist", s)
    s = re.sub(r"@funindex markuplines", r"@funindex markuplist", s)
    if re.search(r'consistent-broken-slope', s):
        stderr_write(NOT_SMART % "consistent-broken-slope")
        stderr_write(
            _("consistent-broken-slope is now handled through the positions callback.\n"))
        stderr_write(
            _("input/regression/beam-broken-classic.ly shows how broken beams are now handled.\n"))
        stderr_write(UPDATE_MANUALLY)
    return s


def paren_matcher(n):
    # poor man's matched paren scanning, gives up
    # after n+1 levels.  Matches any string with balanced
    # parens inside; add the outer parens yourself if needed.
    # Nongreedy.
    return r"[^()]*?(?:\("*n+r"[^()]*?"+r"\)[^()]*?)*?"*n


def undollar_scm(m):
    return re.sub(r"\$(.?)", r"\1", m.group(0))


def undollar_embedded(m):
    s = re.sub(r"#\$", "#", m.group(1))
    # poor man's matched paren scanning after #, gives up
    # after 25 levels.
    s = re.sub(r"#`?\("+paren_matcher(25)+r"\)", undollar_scm, s)
    return m.string[m.start(0):m.start(1)] + s + m.string[m.end(1):m.end(0)]


def strip_export(s):
    return re.sub(r"\(ly:export\s+(" + paren_matcher(25) + r")\)",
                  r"\1", s)


def export_puller(m):
    if not re.search(r"ly:export\s+", m.group(0)):
        return m.group(0)
    return "$" + strip_export(m.string[m.start(0)+1:m.end(0)])


def ugly_function_rewriter(m):
    return m.string[m.start(0):m.start(1)] + strip_export(m.group(1)) + m.string[m.end(1):m.end(0)]


should_really_be_music_function = "(?:\
set-time-signature|empty-music|add-grace-property|\
remove-grace-property|set-accidental-style)"


def record_ugly(m):
    global should_really_be_music_function
    if not re.match(should_really_be_music_function, m.group(1)) \
            and re.search(r"ly:export\s+", m.group(2)):
        should_really_be_music_function = \
            should_really_be_music_function[:-1] + "|" + m.group(1) + ")"
    return m.group(0)


@rule((2, 15, 18), "#$ -> #, ly:export -> $")
def conv(s):
    s = re.sub(r"(?s)#@?\{(.*?)#@?\}", undollar_embedded, s)
    s = re.sub(r"#\(define(?:-public)?\s+\(([-a-zA-Z]+)"
                 + r"\b[^()]*?\)(" + paren_matcher(25)
                 + r")\)", record_ugly, s)
    s = re.sub(r"\(define(?:-public)?\s+\(" + should_really_be_music_function
                 + r"\b[^()]*\)(" + paren_matcher(25)
                 + r")\)", ugly_function_rewriter, s)
    s = re.sub(r"#(?=\(" + should_really_be_music_function + ")", "$", s)
    s = re.sub(r"#\(markup\*(?=\s)", r"$(markup", s)
    s = re.sub(r"#\("+paren_matcher(25)+r"\)", export_puller, s)
    if re.search(r"\(ly:export\s+", s):
        stderr_write(NOT_SMART % "ly:export")
    return s


@rule((2, 15, 19), r"$(set-time-signature ...) -> \time")
def conv(s):
    s = re.sub(r"\$\(set-time-signature\s+([0-9]+)\s+([0-9]+)\s*\)",
                 r"\\time \1/\2", s)
    s = re.sub(r"\$\(set-time-signature\s+([0-9]+)\s+([0-9]+)\s+(" +
                 paren_matcher(5) + r")\)", r"\\time #\3 \1/\2", s)
    if re.search(r"\(set-time-signature\s+", s):
        stderr_write(NOT_SMART % "set-time-signature")
    return s


@rule((2, 15, 20), r"$(set-accidental-style ...) -> \accidentalStyle")
def conv(s):
    s = re.sub(r"\$\(set-accidental-style\s+'([-a-z]+)\)",
                 r'\\accidentalStyle "\1"', s)
    s = re.sub(r"\$\(set-accidental-style\s+'([-a-z]+)\s+'([-A-Za-z]+)\s*\)",
                 r'''\\accidentalStyle #'\2 "\1"''', s)
    s = re.sub(r"(@funindex\s+)set-accidental-style",
                 r"\1\\accidentalStyle", s)
    return s


def brace_matcher(n):
    # poor man's matched brace scanning, gives up
    # after n+1 levels.  Matches any string with balanced
    # braces inside; add the outer braces yourself if needed.
    # Nongreedy.
    return r"[^{}]*?(?:{"*n+r"[^{}]*?"+r"}[^{}]*?)*?"*n


matchstring = r'"(?:[^"\\]|\\.)*"'
matcharg = (r"\s+(?:[$#]['`]?\s*(?:[a-zA-Z][^ \t\n()\\]*|" + matchstring
            + r"|#?\(" + paren_matcher(20) + r"\)|"
            + r"-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)|"
            + r"#(?:[tf]|\\.|@?\{" + brace_matcher(10) + r"#@?\}))|"
            + matchstring + r"|\\[a-z_A-Z]+|[0-9]+(?:/[0-9]+)?|-[0-9]+)")
matchfullmarkup = (r'\\markup\s*(?:@?\{' + brace_matcher(20) + r'\}|' +
                   matchstring + r'|(?:\\[a-z_A-Z][a-z_A-Z-]*(?:' + matcharg +
                   r')*?\s*)*(?:' + matchstring + r"|@?\{" + brace_matcher(20) +
                   r"\}))")
matchmarkup = "(?:" + matchstring + "|" + matchfullmarkup + ")"


@rule((2, 15, 25), r"\(auto)?Footnote(Grob)? -> \footnote")
def conv(s):
    # The following replacement includes the final markup argument in
    # the match in order to better avoid touching the equally named
    # markup function.  The other functions have unique names, so
    # there is no point in including their last, possibly complex
    # argument in the match.
    s = re.sub(r"\\footnote(" + matcharg + (r")(\s*" + matchmarkup)*2 + ")",
                 r"\\footnote\2\1\3", s)
    s = re.sub(r"\\footnoteGrob"+("(" + matcharg + ")")*2 + r"(\s*" + matchmarkup + ")",
                 r"\\footnote\3\2\1", s)
    s = re.sub(r"\\autoFootnoteGrob" + ("(" + matcharg + ")")*2,
                 r"\\footnote\2\1", s)
    s = re.sub(r"\\autoFootnote",
                 r"\\footnote", s)
    return s


@rule((2, 15, 32), r"tempoWholesPerMinute -> \tempo")
def conv(s):
    def sub_tempo(m):
        num = int(m.group(1))
        den = int(m.group(2))

        if (den & (den - 1)) != 0:
            return m.group(0)

        # Don't try dotted forms if they result in less than 30 bpm.
        # It is not actually relevant to get this right since this
        # only occurs in non-printing situations
        if den >= 16 and (num % 7) == 0 and num >= 210:
            return r"\tempo %d.. = %d" % (den/4, num/7)

        if den >= 8 and (num % 3) == 0 and num >= 90:
            return r"\tempo %d. = %d" % (den/2, num/3)

        return r"\tempo %d = %d" % (den, num)

    s = re.sub(r"\\context\s*@?\{\s*\\Score\s+tempoWholesPerMinute\s*=\s*" +
                 r"#\(ly:make-moment\s+([0-9]+)\s+([0-9]+)\)\s*@?\}",
                 sub_tempo, s)
    return s


@rule((2, 15, 39), r"\footnote ... -> \footnote ... \default")
def conv(s):
    def not_first(s):
        def match_fun(m):
            if m.group(1):
                return m.group(0)
            return m.expand(s)
        return match_fun
    s = re.sub("(" + matchfullmarkup + ")|"
                 + r"(\\footnote(?:\s*"
                 + matchmarkup + ")?" + matcharg + "(?:" + matcharg
                 + r")?\s+" + matchmarkup + ")",
                 not_first(r"\2 \\default"), s)
    return s


@rule((2, 15, 40), r"Remove beamWholeMeasure")
def conv(s):
    if re.search(r"\bbeamWholeMeasure\b", s):
        stderr_write(NOT_SMART % "beamWholeMeasure")
        stderr_write(
            _("beamExceptions controls whole-measure beaming.") + "\n")
    return s


@rule((2, 15, 42), r"\set stringTuning -> \set Staff.stringTuning")
def conv(s):
    s = re.sub(r"(\\set\s+)stringTuning", r"\1Staff.stringTuning", s)
    return s


wordsyntax = r"[a-zA-Z\200-\377]+(?:[-_][a-zA-Z\200-\377]+)*"


@rule((2, 15, 43), r'"custom-tuning" = -> custom-tuning =')
def conv(s):
    s = re.sub(
        '\n"(' + wordsyntax + r')"(\s*=\s*\\stringTuning)', "\n\\1\\2", s)
    return s


@rule((2, 16, 0),
      _("bump version for release"))
def conv(s):
    return s


@rule((2, 17, 0), r"blank-*-force -> blank-*-penalty")
def conv(s):
    s = re.sub('blank-page-force', 'blank-page-penalty', s)
    s = re.sub('blank-last-page-force', 'blank-last-page-penalty', s)
    s = re.sub('blank-after-score-page-force',
                 'blank-after-score-page-penalty', s)
    return s


@rule((2, 17, 4), r"\shape Grob #offsets -> \shape #offsets Grob")
def conv(s):
    s = re.sub(r"\\shape(\s+(?:[a-zA-Z]+|" + matchstring + "))(" +
                 matcharg + ")", r"\\shape\2\1", s)
    return s


barstring = r"(\\bar|whichBar|defaultBarType|segnoType|doubleRepeatType|startRepeatType|endRepeatType|doubleRepeatSegnoType|startRepeatSegnoType|endRepeatSegnoType)(\s*[=]?\s*[#]?)"


@rule((2, 17, 5), r"New bar line interface")
def conv(s):
    s = re.sub(barstring + r'"\|:"', '\\1\\2".|:"', s)
    s = re.sub(barstring + r'":\|"', '\\1\\2":|."', s)
    s = re.sub(barstring + r'"\|\|:"', '\\1\\2".|:-||"', s)
    s = re.sub(barstring + r'":\|:"', '\\1\\2":..:"', s)
    s = re.sub(barstring + r'"\.\|\."', '\\1\\2".."', s)
    s = re.sub(barstring + r'"\|S"', '\\1\\2"S-|"', s)
    s = re.sub(barstring + r'"S\|"', '\\1\\2"S-S"', s)
    s = re.sub(barstring + r'":\|S"', '\\1\\2":|.S"', s)
    s = re.sub(barstring + r'":\|S\."', '\\1\\2":|.S-S"', s)
    s = re.sub(barstring + r'"S\|:"', '\\1\\2"S.|:-S"', s)
    s = re.sub(barstring + r'"\.S\|:"', '\\1\\2"S.|:"', s)
    s = re.sub(barstring + r'":\|S\|:"', '\\1\\2":|.S.|:"', s)
    s = re.sub(barstring + r'":\|S\.\|:"', '\\1\\2":|.S.|:-S"', s)
    s = re.sub(barstring + r'":"', '\\1\\2";"', s)
    s = re.sub(barstring + r'"\|s"', '\\1\\2"|-s"', s)
    s = re.sub(barstring + r'"dashed"', '\\1\\2"!"', s)
    s = re.sub(barstring + r'"kievan"', '\\1\\2"k"', s)
    s = re.sub(barstring + r'"empty"', '\\1\\2"-"', s)
    return s


symbol_list = (r"#'(?:" + wordsyntax + r"|\(\s*" + wordsyntax
               + r"(?:\s+" + wordsyntax + r")*\s*\))")

grob_path = symbol_list + r"(?:\s+" + symbol_list + r")*"

grob_spec = wordsyntax + r"(?:\s*\.\s*" + wordsyntax + r")?"

def path_replace(m):
    return m.group(1) + ".".join(re.findall(wordsyntax, m.group(2)))

def convert_overrides_to_dots(s):
    return re.sub(r"(\\(?:override|revert)\s+)(" + grob_spec + r"\s+" + grob_path + ")",
                  path_replace, s)

# The following regexp appears to be unusually expensive to compile,
# so we do it only once instead of for every file
footnotec = re.compile("(" + matchfullmarkup + ")|"
                       + r"(\\footnote(?:\s*"
                       + matchmarkup + ")?" + matcharg + ")(" + matcharg
                       + r")?(\s+" + matchmarkup + r")(\s+\\default)?")

@rule((2, 17, 6), r"""\accidentalStyle #'Context "style" -> \accidentalStyle Context.style
\alterBroken "Context.grob" -> \alterBroken Context.grob
\overrideProperty "Context.grob" -> \overrideProperty Context.grob
\tweak Grob #'symbol -> \tweak Grob.symbol""")
def conv(s):
    def patrep(m):
        def fn_path_replace(m):
            x = ".".join(re.findall(wordsyntax, m.group(2)))
            if x in ["TimeSignature", "KeySignature", "BarLine",
                     "Clef", "StaffSymbol", "OttavaBracket",
                     "LedgerLineSpanner"]:
                x = "Staff." + x
            return m.group(1) + x
        if m.group(1):
            return m.group(0)
        x = m.group(2) + m.group(4)

        if m.group(3):
            x = x + re.sub(r"(\s*)(" + symbol_list + ")", fn_path_replace,
                           m.group(3))

            if not m.group(5):
                x = r"\single" + x
        return x

    s = re.sub(r'''(\\accidentalStyle\s+)#?"([-A-Za-z]+)"''',
                 r"\1\2", s)
    s = re.sub(r'''(\\accidentalStyle\s+)#'([A-Za-z]+)\s+#?"?([-A-Za-z]+)"?''',
                 r"\1\2.\3", s)
    s = re.sub(r'''(\\(?:alterBroken|overrideProperty)\s+)#?"([A-Za-z]+)\s*\.\s*([A-Za-z]+)"''',
                 r"\1\2.\3", s)
    s = re.sub(r'''(\\tweak\s+)#?"?([A-W][A-Za-z]*)"?\s+?#'([a-zX-Z][-A-Za-z]*)''',
                 r"\1\2.\3", s)
    s = re.sub(r'''(\\tweak\s+)#'([a-zX-Z][-A-Za-z]*)''',
                 r"\1\2", s)
    s = footnotec.sub(patrep, s)
    s = re.sub(r'''(\\alterBroken)(\s+[A-Za-z.]+)(''' + matcharg
                 + matcharg + ")", r"\1\3\2", s)
    s = re.sub(r"(\\overrideProperty\s+)(" + grob_spec + r"\s+" + grob_path + ")",
                 path_replace, s)
    s = convert_overrides_to_dots(s)
    return s


@rule((2, 17, 11), r"""\times -> \tuplet, \set tupletSpannerDuration -> \tupletSpan
(ly:make-moment 1 4) -> (ly:make-moment 1/4)
(ly:make-duration 0 0 1 2) -> (ly:make-duration 0 0 1/2)""")
def conv(s):
    def sub_dur(m):
        num = int(m.group(1))
        den = int(m.group(2))

# if den is no power of 2, don't even try to use an unscaled duration
        if (den & (den - 1)) != 0:
            return r"\tupletSpan 1*%d/%d" % (num, den)

        if den >= 4 and num == 7:
            return r"\tupletSpan %d.." % (den/4)

        if den >= 2 and num == 3:
            return r"\tupletSpan %d." % (den/2)

        if num == 1:
            return r"\tupletSpan %d" % den

        return r"\tupletSpan 1*%d/%d" % (num, den)

    s = re.sub(r"\\set\s+tupletSpannerDuration\s*=\s*" +
                 r"#\(ly:make-moment\s+([0-9]+)\s+([0-9]+)\s*\)",
                 sub_dur, s)
    s = re.sub(r"\\unset tupletSpannerDuration",
                 r"\\tupletSpan \\default", s)
    s = re.sub(r"\\times(\s*)([0-9]+)/([0-9]+)",
                 r"\\tuplet\1\3/\2", s)

    s = re.sub(r"(\(ly:make-moment\s+-?[0-9]+)\s+([1-9][0-9]*\))",
                 r"\1/\2", s)
    s = re.sub(r"(\(ly:make-moment\s+-?[0-9]+)\s+([0-9]+\s+-?[0-9]+)\s([0-9]+\))",
                 r"\1/\2/\3", s)
    s = re.sub(r"(\(ly:make-duration\s+-?[0-9]+\s+[0-9]+\s+[0-9]+)\s+([0-9]+\))",
                 r"\1/\2", s)
    return s


@rule((2, 17, 14), r"\accepts ... -> \accepts ... \defaultchild ...")
def conv(s):
    def matchaccepts(m):
        # First weed out definitions starting from an existing
        # definition: we assume that the inherited \defaultchild is
        # good enough for our purposes.  Heuristic: starts with a
        # backslash and an uppercase letter.
        if re.match(r"\s*\\[A-Z]", m.group(1)):
            return m.group(0)
        # existing defaultchild obviously trumps all
        if re.search(r"\\defaultchild[^-_a-zA-Z]", m.group(1)):
            return m.group(0)
        # take the first \\accepts if any and replicate it
        return re.sub("(\r?\n[ \t]*|[ \t]+)"
                      + r"""\\accepts(\s+(?:#?".*?"|[-_a-zA-Z]+))""",
                      r"\g<0>\1\\defaultchild\2",
                      m.group(0), 1)

    s = re.sub(r"\\context\s*@?\{(" + brace_matcher(20) + r")\}",
                 matchaccepts, s)
    return s


@rule((2, 17, 15), r"""#(ly:set-option 'old-relative)
\relative -> \relative c'""")
def conv(s):
    if re.search(r"[#$]\(ly:set-option\s+'old-relative", s):
        stderr_write(NOT_SMART % "#(ly:set-option 'old-relative)")
        stderr_write(UPDATE_MANUALLY)
        raise FatalConversionError()
    # If the file contains a language switch to a language where the
    # name of c is not "c", we can't reliably know which parts of the
    # file will need "c" and which need "do".
    m = re.search(
        r'\\language\s(?!\s*#?"(?:nederlands|deutsch|english|norsk|suomi|svenska))"', s)
    if m:
        # Heuristic: if there is a non-commented { before the language
        # selection, we can't be sure.
        # Also if there is any selection of a non-do language.
        if (re.search("^[^%\n]*\\{", m.string[:m.start()], re.M)
                or re.search(r'\\language\s(?!\s*#?"(?:catalan|espanol|español|italiano|français|portugues|vlaams))"', s)):
            do = "$(ly:make-pitch 0 0)"
        else:
            do = "do'"
    else:
        do = "c'"
    s = re.sub(r"(\\relative)(\s+(\{|[\\<]))",
                 r"\1 " + do + r"\2", s)
    return s


@rule((2, 17, 18),
      "Rename OctavateEight to ClefModifier, rename related properties.")
def conv(s):
    s = re.sub('OctavateEight',
                 'ClefModifier',                   s)
    s = re.sub('octavate-eight-interface',
                 'clef-modifier-interface',        s)
    s = re.sub('clefOctavation',
                 'clefTransposition',              s)
    s = re.sub('clefOctavationFormatter',
                 'clefTranspositionFormatter',     s)
    s = re.sub('clefOctavationStyle',
                 'clefTranspositionStyle',         s)
    s = re.sub('cueClefOctavation',
                 'cueClefTransposition',           s)
    s = re.sub('cueClefOctavationFormatter',
                 'cueClefTranspositionFormatter',  s)
    s = re.sub('cueClefOctavationStyle',
                 'cueClefTranspositionStyle',      s)
    return s


@rule((2, 17, 19), r"\column { \vspace #2 } -> \column { \combine \null \vspace #2 }")
def conv(s):
    def vspace_replace(m):

        # vspace now always adds space and does not, for example, change the
        # impact of either baselineskip or descenders on the line above.
        #
        # We can't simulate the old behavior in a simpler manner.  A command
        # of its own is not really warranted since this behavior combines
        # badly enough with other spacing considerations (like baselineskip
        # and descenders) as to make it not all that useful.  So this
        # conversion rule is here more for compatibility's sake rather than
        # preserving desirable behavior.

        s = re.sub(r"(\\\\?)vspace(\s)",
                     r"\1combine \1null \1vspace\2", m.group(0))
        return s

    s = re.sub(r"\\(?:left-|right-|center-|)column\s*\{" + brace_matcher(20) + r"\}",
                 vspace_replace, s)
    return s


@rule((2, 17, 20), _(r"Flag.transparent and Flag.color inherit from Stem"))
def conv(s):
    s = re.sub(r"(((?:\\once\s*)?)\\override\s+((?:\w+\.)?)Stem\.(transparent|color)\s*=\s*(#\S+))\s+\2\\override\s+\3Flag\.\4\s*=\s*\5",
                 r"\1", s)
    s = re.sub(r"(((?:\\once\s*)?)\\revert\s+((?:\w+\.)?)Stem\.(transparent|color))\s+\2\\revert\s+\3Flag\.\4",
                 r"\1", s)
    s = re.sub(r"(\\tweak\s+((?:\w+\.)?)Stem\.(transparent|color)\s+(#\S+))\s+\\tweak\s+\2Flag\.\3\s+\4",
                 r"\1", s)
    return s


@rule((2, 17, 25), r'''\tempo 4. = 50~60 -> \tempo 4. = 50-60
-| -> -!
pipeSymbol, escapedParenthesisOpenSymbol ... -> "|", "\\(" ...''')
def conv(s):
    #  This goes for \tempo commands ending with a range, like
    #  = 50 ~ 60
    #  and uses - instead.  We don't explicitly look for \tempo since the
    #  complete syntax has a large number of variants, and this is quite
    #  unlikely to occur in other contexts
    s = re.sub(r"(=\s*[0-9]+\s*)~(\s*[0-9]+\s)", r"\1-\2", s)
# Match strings, and articulation shorthands that end in -^_
# so that we leave alone -| in quoted strings and c4--|

    def subnonstring(m):
        if m.group(1):
            return m.group(1)+"!"
        return m.group(0)
    s = re.sub(r"([-^_])\||" + matchstring +
                 r"|[-^_][-^_]", subnonstring, s)
    s = re.sub(r"\bdashBar\b", "dashBang", s)
    orig = ["pipeSymbol",
            "bracketOpenSymbol",
            "bracketCloseSymbol",
            "tildeSymbol",
            "parenthesisOpenSymbol",
            "parenthesisCloseSymbol",
            "escapedExclamationSymbol",
            "escapedParenthesisOpenSymbol",
            "escapedParenthesisCloseSymbol",
            "escapedBiggerSymbol",
            "escapedSmallerSymbol"]
    repl = [r'"|"',
            r'"["',
            r'"]"',
            r'"~"',
            r'"("',
            r'")"',
            r'"\\!"',
            r'"\\("',
            r'"\\)"',
            r'"\\>"',
            r'"\\<"']
    words = r"\b(?:(" + ")|(".join(orig) + r"))\b"

    def wordreplace(m):
        def instring(m):
            return re.sub(r'["\\]', r'\\\g<0>', repl[m.lastindex-1])
        if m.lastindex:
            return repl[m.lastindex-1]
        return '"' + re.sub(words, instring, m.group(0)[1:-1]) + '"'
    s = re.sub(words + "|" + matchstring, wordreplace, s)
    return s


@rule((2, 17, 27), r'''\stringTuning \notemode -> \stringTuning''')
def conv(s):
    s = re.sub(r"\\stringTuning\s*\\notemode(\s*)@?\{\s*(.*?)\s*@?\}",
                 r"\\stringTuning\1\2", s)
    if re.search(r'[^-\w]staff-padding[^-\w]', s):
        stderr_write(NOT_SMART % "staff-padding")
        stderr_write(
            _("Staff-padding now controls the distance to the baseline, not the nearest point."))
    return s


@rule((2, 17, 29), r'''Dynamic_engraver -> New_dynamic_engraver+Dynamic_align_engraver
New_dynamic_engraver -> Dynamic_engraver''')
def conv(s):
    s = re.sub("(\r?\n?[ \t]*\\\\(?:consists|remove)\\s*)(\"?)Dynamic_engraver\\2",
                 r"\1\2New_dynamic_engraver\2\1\2Dynamic_align_engraver\2",
                 s)
# Should we warn about any remaining Dynamic_engraver?  Possibly it
# will do the job just fine.
    s = re.sub("New_dynamic_engraver", "Dynamic_engraver", s)
    return s


@rule((2, 17, 97), r'''(make-relative (a b) b ...) -> make-relative (a b) #{ a b #}...''')
def conv(s):
    s = re.sub(r"(\(make-relative\s+\(\s*(([A-Za-z][-_A-Za-z0-9]*)" +
                 r"(?:\s+[A-Za-z][-_A-Za-z0-9]*)*)\s*\)\s*)\3(?=\s)",
                 r"\1(make-event-chord (list \2))", s)
    s = re.sub(r"(\(make-relative\s+\(\s*([A-Za-z][-_A-Za-z0-9]*" +
                 r"(?:\s+([A-Za-z][-_A-Za-z0-9]*))+)\s*\)\s*)\3(?=\s)",
                 r"\1(make-sequential-music (list \2))", s)
    return s


@rule((2, 18, 0),
      _("bump version for release"))
def conv(s):
    return s


@rule((2, 19, 2), r"\lyricsto \new/\context/... -> \new/\context/... \lyricsto")
def conv(s):
    word = r'(?:#?"[^"]*"|\b' + wordsyntax + r'\b)'
    s = re.sub(r"(\\lyricsto\s*" + word + r"\s*)(\\(?:new|context)\s*" + word
                 + r"(?:\s*=\s*" + word + r")?\s*)",
                 r"\2\1", s)
    s = re.sub(r"(\\lyricsto\s*" + word + r"\s*)\\lyricmode\b\s*",
                 r"\1", s)
    s = re.sub(r"(\\lyricsto\s*" + word + r"\s*)\\lyrics\b\s*",
                 r"\\new Lyrics \1", s)
    s = re.sub(r'\\lyricmode\s*(\\lyricsto\b)', r"\1", s)
    return s


@rule((2, 19, 7), "keySignature -> keyAlterations")
def conv(s):
    s = re.sub(r'\bkeySignature\b', 'keyAlterations', s)
    s = re.sub(r'\blastKeySignature\b', 'lastKeyAlterations', s)
    s = re.sub(r'\blocalKeySignature\b', 'localAlterations', s)
    return s


@rule((2, 19, 11), "thin-kern -> segno-kern")
def conv(s):
    s = re.sub(r'\bthin-kern\b', 'segno-kern', s)
    return s

# before_id is written in a manner where it will only substantially
# (rather than as a lookbefore assertion) match material that could
# not be part of a previous id.  In that manner, one replacement does
# not inhibit an immediately adjacent replacement.


before_id = r'(?:^|(?<!\\)(?:\\\\)+|(?<=[^-_\\a-zA-Z])|(?<=[^a-zA-Z][-_]))'

# after_id is a pure lookbehind assertion so its match string is
# always empty

after_id = r'(?![a-zA-Z]|[-_][a-zA-Z])'


@rule((2, 19, 16), r"""implicitTimeSignatureVisibility -> initialTimeSignatureVisibility
csharp -> c-sharp
TimeSignature: style = #'() -> style = #'numbered""")
def conv(s):
    s = re.sub(r'\bimplicitTimeSignatureVisibility\b',
                 'initialTimeSignatureVisibility', s)
    s = re.sub('(' + before_id + r'[a-g])((?:sharp){1,2}|(?:flat){1,2})'
                 + after_id, r'\1-\2', s)
    s = re.sub(r"""\\override
                   (\s+)
                   ([a-zA-Z]+\.)?TimeSignature.style
                   (\s*)
                   =
                   (\s*)
                   \#'\(\)""",
               r"\\override\1\2TimeSignature.style\3=\4#'numbered",
               s,
               flags=re.VERBOSE)

    s = re.sub(r"""\\tweak
                   (\s+)
                   (TimeSignature\.)?style
                   (\s*)
                   \#'\(\)
                   (\s+)
                   \\time
                   """,
               r"\\tweak\1\2style\3#'numbered\4\\time",
               s,
               flags=re.VERBOSE)
    return s


@rule((2, 19, 22), """whiteout -> whiteout-box
(define-xxx-function (parser location ...) -> (define-xxx-function (...)
(xxx ... parser ...) -> (xxx ... ...)
ChordNameVoice -> ChordNames""")
def conv(s):
    # whiteout -> whiteout-box
    s = re.sub(r"\\whiteout(?![a-z_-])", r"\\whiteout-box", s)
    s = re.sub(r"\b\.whiteout(?![a-z_-])\b", r".whiteout-box", s)
    s = re.sub(r"#'whiteout(?![a-z_-])\b", r"#'whiteout-box", s)
    s = re.sub(r"\bstencil-whiteout\b", r"stencil-whiteout-box", s)

    # (define-xxx-function (parser location ...) -> (define-xxx-function (...)
    def topsubst(s):
        def subst(m):
            def subsub(m):
                s = (m.group(1)
                     + re.sub(r'(?<=\s|["\\()])' + m.group(2) + r'(?=\s|["\\()])',
                              r'(*location*)',
                              re.sub(r'(?<=\s|["\\()])parser(?=\s|["\\()])',
                                     r'(*parser*)', topsubst(m.group(3)))))
                return s
            return re.sub(r'(\([-a-z]+\s*\(+)parser\s+([-a-z]+)\s*((?:.|\n)*)$',
                      subsub, m.group(0))
        return re.sub(r'\(define-(?:music|event|scheme|void)-function(?=\s|["(])'
                      + paren_matcher(20) + r'\)', subst, s)
    s = topsubst(s)

    # (xxx ... parser ...) -> (xxx ... ...)
    def repl(m):
        return m.group(1) + inner(m.group(2))

    def inner(s):
        s = re.sub(r"(\((?:" +
                     r"ly:parser-lexer|" +
                     r"ly:parser-clone|" +
                     r"ly:parser-output-name|" +
                     r"ly:parser-error|" +
                     r"ly:parser-define!|" +
                     r"ly:parser-lookup|" +
                     r"ly:parser-has-error\?|" +
                     r"ly:parser-clear-error|" +
                     r"ly:parser-set-note-names|" +
                     r"ly:parser-include-string|" +
                     r"note-names-language|" +
                     r"display-lily-music|" +
                     r"music->lily-string|" +
                     r"note-name->lily-string|" +
                     r"value->lily-string|"
                     r"check-grob-path|" +
                     r"event-chord-wrap!|" +
                     r"collect-bookpart-for-book|" +
                     r"collect-scores-for-book|" +
                     r"collect-music-aux|" +
                     r"collect-book-music-for-book|" +
                     r"scorify-music|" +
                     r"collect-music-for-book|" +
                     r"collect-book-music-for-book|" +
                     r"toplevel-book-handler|" +
                     r"default-toplevel-book-handler|" +
                     r"print-book-with-defaults|" +
                     r"toplevel-music-handler|" +
                     r"toplevel-score-handler|" +
                     r"toplevel-text-handler|" +
                     r"toplevel-bookpart-handler|" +
                     r"book-music-handler|" +
                     r"context-mod-music-handler|" +
                     r"bookpart-music-handler|" +
                     r"output-def-music-handler|" +
                     r"print-book-with-defaults-as-systems|" +
                     r"add-score|" +
                     r"add-text|" +
                     r"add-music|" +
                     r"make-part-combine-music|" +
                     r"make-directed-part-combine-music|" +
                     r"add-quotable|" +
                     r"paper-variable|" +
                     r"make-autochange-music|" +
                     r"context-mod-from-music|" +
                     r"context-defs-from-music)" +
                     r'(?=\s|[()]))(' + paren_matcher(20) + ")"
                     r"(?:\s+parser(?=\s|[()])|\s*\(\*parser\*\))", repl, s)
        return s
    s = inner(s)
    # This is the simplest case, resulting from one music function
    # trying to call another one via Scheme.  The caller is supposed
    # to have its uses of parser/location converted to
    # (*parser*)/(*location*) already.  Other uses of
    # ly:music-function-extract are harder to convert but unlikely.
    s = re.sub(r'(\(\s*\(ly:music-function-extract\s+' + wordsyntax +
                 r'\s*\)\s+)\(\*parser\*\)\s*\(\*location\*\)', r'\1',
                 s)

    s = re.sub(r'ChordNameVoice', r'ChordNames', s)
    return s


@rule((2, 19, 24), r"""music-has-type -> music-is-of-type?
\applyOutput #'Context -> \applyOutput Context""")
def conv(s):
    s = re.sub(r'(?<=\s|["\\()])' + "music-has-type" + r'(?=\s|["\\()])',
                 "music-is-of-type?", s)
    s = re.sub(r"(\\applyOutput\s+)#'([a-zA-Z])", r"\1\2", s)
    return s


@rule((2, 19, 28), r"c:5.x, c:5^x, c:sus -> c:3.5.x, c:3.5^x, c:5")
def conv(s):
    s = re.sub(r":5([.^][1-9])", r":3.5\1", s)
    # row back for self-defeating forms
    s = re.sub(r":3\.5((?:\.[0-9]+)*\^(?:[0-9]+\.)*)3\.", r":5\1", s)
    s = re.sub(
        r":3\.5((?:\.[0-9]+)*\^?:[0-9]+(?:\.[0-9]+)*)\.3(?![.0-9])", r":5\1", s)
    s = re.sub(r":3\.5((?:\.[0-9]+)*)\^3(?=\s|\})", r":5\1", s)
    s = re.sub(r":sus(?=\s|\})", ":5", s)
    s = re.sub(r":1\.5(?=\s|[.^}])", r":5", s)
    return s


@rule((2, 19, 29), r"partcombine*Once -> \once \partcombine*")
def conv(s):
    s = re.sub(r"(\\partcombine(?:Apart|Chords|Unisono|SoloII?|Automatic))Once\b",
                 r"\\once \1", s)
    s = re.sub(r"(\\partcombineForce" + matcharg + r")\s*##f(\s)",
                 r"\1\2", s)
    s = re.sub(r"(\\partcombineForce" + matcharg + r")\s*##t(\s)",
                 r"\\once \1\2", s)
    return s


@rule((2, 19, 32), r"whiteout-box -> whiteout")
def conv(s):
    s = re.sub(r"\\whiteout-box(?![a-z_-])", r"\\whiteout", s)
    s = re.sub(r"\b\.whiteout-box(?![a-z_-])\b", r".whiteout", s)
    s = re.sub(r"#'whiteout-box(?![a-z_-])\b", r"#'whiteout", s)
    return s


@rule((2, 19, 39), r"...-spacing #'prop... = -> ...-spacing.prop... =")
def conv(s):
    s = re.sub(r"(\s)((?:markup-markup-spacing|markup-system-spacing"
                 r"|score-markup-spacing|last-bottom-spacing"
                 r"|score-system-spacing|system-system-spacing"
                 r"|top-markup-spacing|top-system-spacing)"
                 r"(?:\s+#\s*'\s*" + wordsyntax + r")+)(?=\s*=)", path_replace, s)
    return s


@rule((2, 19, 40), r"\time #'(2 3) ... -> \time 2,3 ...")
def conv(s):
    def repl(m):
        return m.group(1) + re.sub(r"\s+", ",", m.group(2))

    s = re.sub(r"(beatStructure\s*=\s*)#'\(([0-9]+(?:\s+[0-9]+)+)\)",
                 repl, s)

    s = re.sub(r"(\\time\s*)#'\(([0-9]+(?:\s+[0-9]+)+)\)", repl, s)

    def repl(m):
        subst = re.sub(r"\s+", ",", m.group(1))
        return subst + (4 + len(m.group(1)) - len(subst)) * " " + m.group(2)

    s = re.sub(r"#'\(([0-9]+(?:\s+[0-9]+)+)\)(\s+%\s*beatStructure)",
                 repl, s)
    return s


@rule((2, 19, 46), r"\context ... \modification -> \context ... \with \modification")
def conv(s):
    word = r'(?:#?"[^"]*"|\b' + wordsyntax + r'\b)'
    mods = "|".join(re.findall("\n(" + wordsyntax + r")\s*=\s*\\with(?:\s|\\|\{)", s)
                    + ['RemoveEmptyStaves', 'RemoveAllEmptyStaves'])
    s = re.sub(r"(\\(?:drums|figures|chords|lyrics|addlyrics|"
                 + r"(?:new|context)\s*" + word
                 + r"(?:\s*=\s*" + word + r")?)\s*)(\\(?:" + mods + "))",
                 r"\1\\with \2", s)
    return s


@rule((2, 19, 49), r"""id -> output-attributes.id or output-attributes
for \tweak, \override, \overrideProperty, and \revert""")
def conv(s):
    # path cannot start with '-' or '_' and matches zero or more path
    # units that each end in a dot
    path = r"(?:[a-zA-Z\200-\377](?:[-_]?[a-zA-Z\200-\377])*(?:\s*\.\s*))*"

    # Manual editing is needed when id is set to #(...) or \xxx
    manual_edits = r"(\\(?:tweak|override|overrideProperty)\s+" + \
        path + r")id(\s*=?\s*(?:\\|#\s*\())"
    automatic = r"(\\(?:tweak|override|overrideProperty|revert)\s+" + path + r")id"
    if re.search(manual_edits, s):
        stderr_write(NOT_SMART % "\"output-attributes\"")
        stderr_write(
            _("Previously the \"id\" grob property (string) was used for SVG output.") + "\n")
        stderr_write(
            _("Now \"output-attributes\" (association list) is used instead.") + "\n")
        stderr_write(UPDATE_MANUALLY)

    # First, for manual editing cases we convert 'id' to 'output-attributes'
    # because Grob.output-attributes.id = #(lambda ... ) will not work.
    # Then for the rest we convert 'id' to 'output-attributes.id'
    s = re.sub(manual_edits, r"\1output-attributes\2", s)
    s = re.sub(automatic, r"\1output-attributes.id", s)
    return s


@rule((2, 20, 0), r'''\language "deutsch": beh -> heh''')
def conv(s):
    changes = re.findall(r'\\language\s*#?"([a-zçñ]+)"', s)
    if changes and (changes.count('deutsch') == len(changes)):
        s = re.sub(r'\bbeh\b', 'heh', s)
    return s


matchscmarg = (r'(?:[a-zA-Z_][-a-zA-Z_0-9]*|"(?:[^\\"]|\\.)*"|[-+]?[0-9.]+|\('
               + paren_matcher(10) + r"\))")

string_duration_re = (r'(?P<startquote>#?")'
                      r'(?P<dur>1|2|4|8|16|32|64|128|256|breve|longa|maxima)'
                      r'(?P<ws>\s*)'
                      r'(?P<dots>[.]*)'
                      r'(?P<endquote>")')

def to_ly_duration(match):
    # Take a match against string_duration_re, possibly embedded in a
    # larger regex.  Return the corresponding duration in LilyPond
    # syntax with braces, like "{4.}" or "{\longa}".
    if match.group("dur") in (r"breve", r"longa", r"maxima"):
        new_dur = '\\' + match.group("dur")
    else:
        new_dur = match.group("dur")
    return (match.group()[:match.start("startquote")-match.start()]
            + '{' + new_dur
            + match.group("dots") + '}'
            + match.group()[match.end("endquote")-match.start():])

def to_scm_duration(match):
    # Same as string_to_ly_duration, with result in Scheme syntax.
    # "4." => (ly:make-duration 2 1)
    # "longa" => (ly:make-duration -2 0)
    dur_log = {"1": 0, "2": 1, "4": 2, "8": 3, "16": 4,
               "32": 5, "64": 6, "128": 7, "256": 8,
               "breve": -1, "longa": -2, "maxima": -4}[match.group("dur")]
    dot_count = len(match.group("dots"))
    new = f"(ly:make-duration {dur_log} {dot_count})"
    return (match.group()[:match.start("startquote")-match.start()]
            + new
            + match.group()[match.end("endquote")-match.start():])

# \note #"4." => \note {4.}  in 2.21.0
# \rest #"4." => \rest {4.} in 2.23.1
def convert_string_to_duration_for_command(markup_command, s):
    s = re.sub(rf'\\{markup_command}\s*{string_duration_re}', to_ly_duration, s)
    s = re.sub(rf'#:{markup_command}\s+{string_duration_re}', to_scm_duration, s)
    return s

@rule((2, 21, 0), r"""\note #"4." -> \note {4.}
\markup-command #" -> \markup-command "
\partcombine* -> \partCombine, \autochange -> \autoChange
scripts.trilelement -> scripts.trillelement
\fermataMarkup -> \fermata
remove \\powerChords, deprecate banter-chord-names and jazz-chord-names
\compressFullBarRests  -> \compressEmptyMeasures
""")
def conv(s):
    s = convert_string_to_duration_for_command("note", s)
    s = re.sub(r"\(tuplet-number::(?:fraction-with-notes|non-default-fraction-with-notes|append-note-wrapper)\s" +
                 paren_matcher(20) + r"\)",
               lambda match: re.sub(string_duration_re, to_scm_duration, match.group()),
               s)
    s = re.sub(r'(\\(?:fret-diagram(?:-terse)?|harp-pedal|justify-string'
                 r'|lookup|musicglyph|postscript|simple|tied-lyric|verbatim-file'
                 r'|with-url|wordwrap-string'
                 r'|discant|freeBass|stdBass|stdBassIV|stdBassV|stdBassVI'
                 r')\s*)[#$](\\?")',
                 r'\1\2', s)
    s = re.sub(r"\\partcombine(Force|Up|Down|Chords|Apart|Unisono|SoloI|SoloII|Automatic|)\b",
                 r"\\partCombine\1", s)
    s = re.sub(r"\\autochange", r"\\autoChange", s)
    s = re.sub(r'\\powerChords', '', s)
    s = re.sub(r'"scripts\.trilelement"', r'"scripts.trillelement"', s)
    s = re.sub(r"\\fermataMarkup", r"\\fermata", s)
    s = re.sub(r"\\(compress|expand)FullBarRests", r"\\\1EmptyMeasures", s)
    if re.search(r"#(banter|jazz)-chordnames", s):
        stderr_write(NOT_SMART % "alternative chord naming functions")
        stderr_write(UPDATE_MANUALLY)
    return s


@rule((2, 21, 2), r'''\tocItem "string" -> \tocItem \markup "string"''')
def conv(s):
    s = re.sub(r'\\tocItem\s+"', r'\\tocItem \\markup "', s)
    return s


@rule((2, 22, 0), _("bump version for release"))
def conv(s):
    return s


@rule((2, 23, 1), r"""
combine u/d variants of triangle, do, re, and ti noteheads
rename bar line "S" to "S-||"
rename bar line "S-|" to "S"
\rest "4." -> \rest {4.}
""")
def conv(s):
    s = re.sub(r'"noteheads\.[ud](1|2)(triangle|(?:do|re|ti)(?:Thin)?)"',
               r'"noteheads.s\1\2"', s)
    s = re.sub(r'\\bar(\s+)"S"', r'\\bar\1"S-||"', s)
    s = re.sub(r'\\bar(\s+)"S-\|"', r'\\bar\1"S"', s)
    s = re.sub(r'segnoType(\s+=\s+)#?"S"', r'segnoType\1"S-||"', s)
    s = re.sub(r'segnoType(\s+=\s+)#?"S-\|"', r'segnoType\1"S"', s)
    s = convert_string_to_duration_for_command("rest", s)
    # Be more general than \override #'(multi-measure-rest . #t),
    # there's also \override #'((something . else) (multi-measure-rest . #t))
    if "#'(multi-measure-rest . #t)" in s and r"\rest-by-number" in s:
        # Don't convert blindly since it may also be use of \rest-by-number
        # for a normal rest and \rest with \override #'(multi-measure-rest . #t)
        # somewhere else.
        stderr_write(NOT_SMART % r"\override #'(multi-measure-rest . #t) \rest-by-number")
        stderr_write(r"""
Instead of (for example)
  \markup \override #'(multi-measure-rest . #t) \rest-by-number #0 #0
use
  \markup \multi-measure-rest-by-number #1

The argument of \multi-measure-rest-by-number is the number of measures
the multi-measure rest lasts.
""")
        stderr_write(UPDATE_MANUALLY)
    return s


melody_engraver_warning = r"""
If you had

  \override Stem.neutral-direction = #DOWN

and

  \override Stem.neutral-direction #'()

to turn the use of the Melody_engraver off
and on, respectively, you should instead use

  \set suspendMelodyDecisions = ##t

and

  \set suspendMelodyDecisions = ##f

"""

@rule((2, 23, 2), r"""
warn about behavior change of Melody_engraver with Stem.neutral-direction
adapt module names to (lily) namespace
""")
def conv(s):
    # Detect changes to the Stem.neutral-direction property
    # in conjunction with the Melody_engraver. The string
    # "Stem.neutral-direction" is sufficient for the former,
    # since there is no situation where \tweak neutral-direction ...
    # would cause the property to end up on the Stem.
    #
    # Convert
    #   \consists Melody_engraver
    #   \override Stem.neutral-direction = #'()
    # to just
    #   \consists Melody_engraver
    #
    # Warn about other uses, it's too tricky to convert them
    # (e.g., \tweak Stem.color \tweak Stem.neutral-direction #DOWN ...
    # should become \once \set suspendMelodyDecisions = ##t \tweak Stem.color ...).
    neutral_dir = r'Stem\.neutral-direction'
    neutral_dir_override = r"\\override\s+{}\s+=\s+#'\(\)".format(neutral_dir)
    melody_engraver = r'\\consists\s+"?Melody_engraver"?'
    typical_usage = r'({})\s+{}'.format(melody_engraver, neutral_dir_override)
    s = re.sub(typical_usage, r"\1", s)
    if re.search(neutral_dir, s) and re.search('Melody_engraver', s):
        stderr_write(NOT_SMART % "Stem.neutral-direction with Melody_engraver")
        stderr_write(melody_engraver_warning)
        stderr_write(UPDATE_MANUALLY)

    s = re.sub(r'\(scm (accreg|display-lily|graphviz|guile-debugger|song|to-xml)\)',
               r'(lily \1)', s)
    return s

round_filled_polygon_warning = r"""
ly:round-filled-polygon was renamed to ly:round-polygon and now takes
an additional optional parameter specifying whether the polygon is filled.
The default value of the extroversion optional parameter was changed from
-1 to 0.
"""

@rule((2, 23, 3), r"""
glyph-name-alist -> alteration-glyph-name-alist
ly:round-filled-polygon -> ly:round-polygon
""")
def conv(s):
    # The negative lookbehind assertion is to avoid matching
    # standard-alteration-glyph-name-alist and similar.
    s = re.sub(r"(?<!-)glyph-name-alist", "alteration-glyph-name-alist", s)
    if "ly:round-filled-polygon" in s:
        stderr_write(NOT_SMART % "ly:round-filled-polygon")
        stderr_write(round_filled_polygon_warning)
        stderr_write(UPDATE_MANUALLY)
    return s

trill_pitch_group_re = r"""TrillPitchGroup\.
(
  font # recognize all font-something properties
  | color
  | extra-offset
  | layer
  | output-attributes
  | rotation
  | stencil
  | stencils
  | transparent
  | whiteout # also whiteout-style
)
"""

repl = r"TrillPitchParentheses.\1"

on_the_fly_replacements = (
    (r"[\\#$]print-page-number-check-first", r"\\if \\should-print-page-number"),
    (r"[\\#$]create-page-number-stencil", r"\\if \\should-print-page-numbers-global"),
    (r"[\\#$]print-all-headers", r"\\if \\should-print-all-headers"),
    (r"[\\#$]first-page", r"\\if \\on-first-page"),
    (r"[\\#$]not-first-page", r"\\unless \\on-first-page"),
    (r"[#$]\(on-page (\d+)\)", r"\\if \\on-page #\1"),
    (r"[\\#$]last-page", r"\\if \\on-last-page"),
    (r"[\\#$]part-first-page", r"\\if \\on-first-page-of-part"),
    (r"[\\#$]not-part-first-page", r"\\unless \\on-first-page-of-part"),
    (r"[\\#$]part-last-page", r"\\if \\on-last-page-of-part"),
    (r"[\\#$]not-single-page", r"\\unless \\single-page"),
)

@rule((2, 23, 4), r"""
ly:context-now -> ly:context-current-moment
ControlPointItem, ControlPointSpanner -> ControlPoint
ControlPolygonItem, ControlPolygonSpanner -> ControlPolygon
FootnoteItem, FootnoteSpanner -> Footnote
BalloonTextItem, BalloonTextSpanner -> BalloonText
\on-the-fly #some-procedure -> \if \some-condition
""")
def conv(s):
    s = re.sub("ly:context-now", "ly:context-current-moment", s)
    # It's unlikely that users would have wanted different settings
    # for the item type and the spanner type, so this should be reasonable.
    item_spanner = (r"(ControlPoint|ControlPolygon|Footnote|BalloonText)"
                    r"(Item|Spanner)")
    s = re.sub(item_spanner, r"\1", s)
    s = re.sub("ParenthesesItem", "Parentheses", s)
    s = re.sub("parentheses-item::", "parentheses-interface::", s)
    s = re.sub(trill_pitch_group_re, repl, s, flags=re.VERBOSE)
    for pattern, replacement in on_the_fly_replacements:
        complete_pattern = r"\\on-the-fly\s+" + pattern
        s = re.sub(complete_pattern, replacement, s)
    return s

@rule((2, 23, 5), r"""
Mark_tracking_translator
""")
def conv(s):
    if re.search(r'\\consists\s+"?Mark_engraver"?', s):
        stderr_write(NOT_SMART % "\\consists Mark_engraver")
        stderr_write(_("If independent mark sequences are desired, use multiple Mark_tracking_translators."))
        stderr_write('\n')
        stderr_write(UPDATE_MANUALLY)
    return s

dash_abbreviations = ["Hat", "Plus", "Dash", "Bang", "Larger", "Dot", "Underscore"]


markup2string_warning = """
The signature of the markup->string Scheme function changed.  Calls with
just one argument are not affected.  Calls using the second optional
argument, the list of header modules, should be changed from

  (markup->string <markup> <header list>)

to

  (markup->string <markup> #:props (headers-property-alist-chain <header list>))

"""

@rule((2, 23, 6), r"""
defaultBarType -> measureBarType
markFormatter -> rehearsalMarkFormatter
startRepeatType -> startRepeatBarType (etc.)
make-articulation "X" -> make-articulation 'X
'articulation-type "X" -> 'articulation-type 'X
dashX = "Y" -> dashX = #(make-articulation 'Y)
markup->string 2nd argument change
ly:grob-spanned-rank-interval -> ly:grob-spanned-column-rank-interval
""")
# It would be nicer to do
# dashX = "Y" -> dashX = \Y
# but it is not guaranteed that for any 'symbol valid as 'articulation-type
# (see the list in scm/script.scm), there is a corresponding after-event \symbol
# defined via #(make-articulation 'symbol ...) in ly/script-init.ly or
# ly/gregorian.ly. (Example: There is no \comma as of 2.23.5)
def conv(s):
    s = re.sub("defaultBarType", "measureBarType", s)
    s = re.sub("doubleRepeatSegnoType", "doubleRepeatSegnoBarType", s)
    s = re.sub("doubleRepeatType", "doubleRepeatBarType", s)
    s = re.sub("endRepeatSegnoType", "endRepeatSegnoBarType", s)
    s = re.sub("endRepeatType", "endRepeatBarType", s)
    s = re.sub("fineSegnoType", "fineSegnoBarType", s)
    s = re.sub("fineStartRepeatSegnoType", "fineStartRepeatSegnoBarType", s)
    s = re.sub("markFormatter", "rehearsalMarkFormatter", s)
    s = re.sub("segnoType", "segnoBarType", s)
    s = re.sub("startRepeatSegnoType", "startRepeatSegnoBarType", s)
    s = re.sub("startRepeatType", "startRepeatBarType", s)
    s = re.sub("underlyingRepeatType", "underlyingRepeatBarType", s)
    s = re.sub(r'''((make-articulation|'articulation-type)\s+)"(\w+)"''', r"\1'\3", s)
    s = re.sub(r'(dash(%s)\s+)=(\s+)"(\w+)"' % "|".join(dash_abbreviations),
               r"\1=\3#(make-articulation '\4)", s)
    # The case (markup->string <symbol>) is easy to detect and should
    # not be warned about.  Cases with one argument that is more complex
    # than a symbol are harder to detect reliably, so we conservatively
    # print the warning.
    if re.search(r"(?!(?<=\()markup\->string\s+\w+\))markup->string", s):
        stderr_write(NOT_SMART % "markup->string")
        stderr_write(markup2string_warning)
        stderr_write(UPDATE_MANUALLY)
    s = s.replace("ly:grob-spanned-rank-interval", "ly:grob-spanned-column-rank-interval")
    return s

bar_numbers_warning = _(r"""
Warning:

Your score contains a setting of barNumberVisibility to
#all-bar-numbers-visible and a setting of BarNumber.break-visibility,
but not \bar "" command.  This likely means that you have
been using

  \set Score.barNumberVisibility = #all-bar-numbers-visible
  \override Score.BarNumber.break-visibility = #end-of-line-invisible

in order to print bar numbers in the middle of systems
in addition to bar numbers at the beginning of systems.
In 2.23.7 and later, this will print the first bar number
too, which has always been the intended effect of
#all-bar-numbers-visible, but did not work without \bar ""
for technical reasons.  If you do not want the first
bar number, remove the command

  \set Score.barNumberVisibility = #all-bar-numbers-visible
""")

@rule((2, 23, 7), r"""
all-bar-numbers-visible + BarNumber.break-visibility + no \bar "" -> warning
""")
def conv(s):
    if (
        "all-bar-numbers-visible" in s
        and "BarNumber.break-visibility" in s
        and r'\bar ""' not in s
    ):
        stderr_write(bar_numbers_warning)
    return s

@rule((2, 23, 8), r"""
scripts.augmentum -> dots.dotvaticana
scripts.trillelement -> scripts.trill_element
ly:skyline::get-touching-point -> ly:skyline-touching-point
ly:skyline::get-distance -> ly:skyline-distance
ly:skyline::get-max-height -> ly:skyline-max-height
ly:skyline::get-max-height-position -> ly:skyline-max-height-position
ly:skyline::get-height -> ly:skyline-height
Remove Default_bar_line_engraver
""")
def conv(s):
    s = re.sub(r"scripts\.augmentum", r"dots.dotvaticana", s)
    s = re.sub(r"scripts\.trillelement", r"scripts.trill_element", s)
    s = re.sub(r"ly:skyline::get-touching-point", "ly:skyline-touching-point", s)
    s = re.sub(r"ly:skyline::get-distance", "ly:skyline-distance", s)
    s = re.sub(r"ly:skyline::get-max-height", "ly:skyline-max-height", s)
    s = re.sub(r"ly:skyline::get-max-height-position", "ly:skyline-max-height-position", s)
    s = re.sub(r"ly:skyline::get-height", "ly:skyline-height", s)
    s = re.sub(r'[\t ]*\\(consists|remove)\s*"?Default_bar_line_engraver"?[\t ]*\n?',
               r'', s)
    return s

percent_x_off_warning = r"""
The X-offset property of PercentRepeat is no longer relative to the
default position (centered), but to the left of the span within
which the object is centered.  Overrides/tweaks to PercentRepeat.X-offset
should be updated.
"""

@rule((2, 23, 9), r"""
ly:percent-repeat-item-interface::xxx -> ly:percent-repeat-interface::xxx
""")
def conv(s):
    s = re.sub(r"ly:percent-repeat-item-interface::", "ly:percent-repeat-interface::", s)
    if "PercentRepeat.X-offset" in s:
        stderr_write(NOT_SMART % "PercentRepeat.X-offset")
        stderr_write(percent_x_off_warning)
        stderr_write(UPDATE_MANUALLY)
    return s

@rule((2, 23, 10), r"""
automaticBars = ##f -> measureBarType = #'()
\\bar "-" -> \\bar ""
BarType = "-" -> BarType = ""
\featherDurations #(ly:make-moment x/y) -> \featherDurations x/y
\consists Chord_name_engraver -> \consists Chord_name_engraver \consists Current_chord_text_engraver
\remove Chord_name_engraver -> \remove Chord_name_engraver \remove Current_chord_text_engraver
)
""")
def conv(s):
    s = re.sub(r"automaticBars\s*=\s*##f", r"measureBarType = #'()", s)
    if "automaticBars" in s:
        stderr_write(NOT_SMART % "advanced use of automaticBars")
        stderr_write("""
The automaticBars property has been removed.  Instead, set
measureBarType to #'() or a valid bar type.
""")
        stderr_write(UPDATE_MANUALLY)
    s = re.sub(r'\\bar\s*"-"', r'\\bar ""', s)
    s = re.sub(r'BarType\s*=\s*"-"', r'BarType = ""', s)
    s = re.sub(r'(\\featherDurations\s+)#\(ly:make-moment\s+([0-9/]+)\)',
               r'\1\2', s)
    s = re.sub(r'\\(consists|remove) "?Chord_name_engraver"?',
               r'\\\1 Chord_name_engraver \\\1 Current_chord_text_engraver',
               s)
    # This change is also in the rule for 2.13.18.  It is being
    # replicated here because the removal was only done in 2.23.10.
    # This ensures that a score that had previously been updated to a
    # version between 2.13.18 and 2.23.10 without running convert-ly
    # can still be fixed in the 2.23.10 upgrade using convert-ly.
    # Since the change was advertised earlier, this is not part of the
    # rule description.
    s = re.sub(r"\\RemoveEmpty(|Drum|Rhythmic|Tab)StaffContext",
                 r"\\\1Staff \\RemoveEmptyStaves",
                 s)
    s = re.sub(r"\\AncientRemoveEmptyStaffContext",
                 r"\\VaticanaStaff \\RemoveEmptyStaves",
                 s)
    return s

@rule((2, 23, 11), r"""
\bar "B" -> \bar "B-|" for B in { .| .|: [|: S S.|: }
""")
def conv(s):
    # We convert only \bar because automatic bar lines configured with
    # context properties layer themselves.
    changed_bar_types = [ # bar types which had an implicit "|" at EOL
        r'\.\|',    # .|
        r'\.\|:',   # .|:
        r'\[\|:',   # [|:
        r'S',       # S
        r'S\.\|:']  # S.|:
    s = re.sub(r'\\bar\s*"(' + '|'.join(changed_bar_types) + ')"',
               r'\\bar "\1-|"', s)
    # New syntax was introduced in 2.17.6, but this version adds a warning,
    # which is more insistent.
    s = convert_overrides_to_dots(s)
    return s

fine_iteration_warning = _(r"""
Warning: \fine no longer enforces the end of the music.  If your piece
has music following \fine that you want to exclude when it is
unfolded, use \volta to exclude it.
""")

new_ancient_divisio_grob_warning = _(r"""
MensuralStaff and VaticanaStaff now use Divisio_engraver to engrave
divisiones as Divisio grobs.

Previously, the respective Voice-aliased contexts used
Breathing_sign_engraver to engrave divisiones as BreathingSign grobs.
Because of the new names and the move from Voice to Staff, layout
adjustments for the old scheme are not effective for the new.

If you are not content with the new default layout, deal with Divisio
and Divisio_engraver in the appropriate Staff-aliased context.
""")

new_modern_divisio_grob_warning = _(r"""
GregorianTranscriptionStaff now engraves \divisioMinima,
\divisioMaior, and \divisioMaxima as BarLine grobs using Bar_engraver,
and engraves \caesura and \virgula as Divisio grobs using
Divisio_engraver.

Previously, GregorianTranscriptionVoice used Breathing_sign_engraver
to engrave these as BreathingSign grobs.  Because of the new names and
the move from Voice to Staff, layout adjustments for the old scheme
are not effective for the new.

If you are not content with the new default layout, deal with BarLine,
Bar_engraver, Divisio, and Divisio_engraver in
GregorianTranscriptionStaff context.  \EnableGregorianDivisiones may
also be used to switch to engraving Divisio grobs instead of BarLine
grobs.
""")

@rule((2, 23, 12), r"""
barAlways = ##t -> forbidBreakBetweenBarLines = ##f
\fine no longer stops iteration
New Divisio grob
""")
def conv(s):
    s = re.sub(r'barAlways\s*=\s*##t', r'forbidBreakBetweenBarLines = ##f', s)
    s = re.sub(r'barAlways\s*=\s*##f', r'forbidBreakBetweenBarLines = ##t', s)
    if ('\\fine' in s) and (('\\repeat segno' in s) or
                            ('\\repeat volta' in s)):
        stderr_write(NOT_SMART % "music following \\fine")
        stderr_write(fine_iteration_warning)
        stderr_write(UPDATE_MANUALLY)
    if re.search(r"GregorianTranscription(Staff|Voice)", s) and \
        (("BreathingSign" in s) or ("Breathing_sign_engraver" in s)):
         stderr_write(NOT_SMART % "BreathingSign to BarLine or Divisio")
         stderr_write(new_modern_divisio_grob_warning)
         stderr_write(UPDATE_MANUALLY)
    if re.search(r"(Mensural|Vaticana)(Staff|Voice)", s) and \
        (("BreathingSign" in s) or ("Breathing_sign_engraver" in s)):
         stderr_write(NOT_SMART % "BreathingSign to Divisio")
         stderr_write(new_ancient_divisio_grob_warning)
         stderr_write(UPDATE_MANUALLY)
    return s

remove_bar_always_warning = _(r"""
The barAlways property has been removed.  Instead, use
forbidBreakBetweenBarLines.
""")

@rule((2, 23, 13), r"""
filtered-map -> filter-map
Remove barAlways
""")
def conv(s):
    s = re.sub(r"filtered-map", "(@ (srfi srfi-1) filter-map)", s)
    if "barAlways" in s:
        stderr_write(NOT_SMART % "advanced use of barAlways")
        stderr_write(remove_bar_always_warning)
        stderr_write(UPDATE_MANUALLY)
    return s

@rule((2, 23, 14), r"""
changed convention for ly:skylines-for-stencil second argument
""")
def conv(s):
    if "ly:skylines-for-stencil" in s:
        stderr_write(NOT_SMART % "ly:skylines-for-stencil second argument")
        stderr_write("""
The second argument to ly:skylines-for-stencil is now the 'horizon axis', which
is the opposite of the convention used previously.
""")
        stderr_write(UPDATE_MANUALLY)
    return s

@rule((2, 24, 0), _("bump version for release"))
def conv(s):
    return s


# Guidelines to write rules (please keep this at the end of this file)
#
# - keep at most one rule per version; if several conversions should be done,
# concatenate them into a single "conv" function;
#
# - enclose strings to be localized with `_(' and  `)';
#
# - write rule for bumping major stable version with
#
#     _ ("bump version for release")
#
# as exact description.
