+@rule ((2, 17, 97), r'''(make-relative (a b) b ...) -> make-relative (a b) #{ a b #}...''')
+def conv (str):
+ str = 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))", str)
+ str = 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))", str)
+ return str
+
+@rule ((2, 18, 0),
+ _ ("bump version for release"))
+def conv (str):
+ return str
+
+@rule ((2, 19, 2), r"\lyricsto \new/\context/... -> \new/\context/... \lyricsto")
+def conv (str):
+ word=r'(?:#?"[^"]*"|\b' + wordsyntax + r'\b)'
+ str = re.sub (r"(\\lyricsto\s*" + word + r"\s*)(\\(?:new|context)\s*" + word
+ + r"(?:\s*=\s*" + word + r")?\s*)",
+ r"\2\1", str)
+ str = re.sub (r"(\\lyricsto\s*" + word + r"\s*)\\lyricmode\b\s*",
+ r"\1", str)
+ str = re.sub (r"(\\lyricsto\s*" + word + r"\s*)\\lyrics\b\s*",
+ r"\\new Lyrics \1", str)
+ str = re.sub (r'\\lyricmode\s*(\\lyricsto\b)', r"\1", str)
+ return str
+
+@rule ((2, 19, 7), "keySignature -> keyAlterations")
+def conv(str):
+ str = re.sub (r'\bkeySignature\b', 'keyAlterations', str)
+ str = re.sub (r'\blastKeySignature\b', 'lastKeyAlterations', str)
+ str = re.sub (r'\blocalKeySignature\b', 'localAlterations', str)
+ return str
+
+@rule ((2, 19, 11), "thin-kern -> segno-kern")
+def conv(str):
+ str = re.sub (r'\bthin-kern\b', 'segno-kern', str)
+ return str
+
+# 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), """implicitTimeSignatureVisibility -> initialTimeSignatureVisibility
+csharp -> c-sharp""")
+def conv(str):
+ str = re.sub (r'\bimplicitTimeSignatureVisibility\b', 'initialTimeSignatureVisibility', str)
+ str = re.sub ('(' + before_id + r'[a-g])((?:sharp){1,2}|(?:flat){1,2})'
+ + after_id, r'\1-\2', str)
+ return str
+
+@rule ((2, 19, 22), """(define-xxx-function (parser location ...) -> (define-xxx-function (...)
+(xxx ... parser ...) -> (xxx ... ...)""")
+def conv(str):
+ def subst(m):
+ def subsub(m):
+ str = (m.group (1)
+ + re.sub ('(?<=\s|["\\()])' + m.group (2) + r'(?=\s|["\\()])',
+ r'(*location*)',
+ re.sub (r'(?<=\s|["\\()])parser(?=\s|["\\()])',
+ r'(*parser*)', m.group (3))))
+ return str
+ return re.sub (r'(\([-a-z]+\s*\(+)parser\s+([-a-z]+)\s*((?:.|\n)*)$',
+ subsub, m.group (0))
+ str = re.sub (r'\(define-(?:music|event|scheme|void)-function(?=\s|["(])'
+ + paren_matcher (20) + r'\)', subst, str)
+
+ def repl (m):
+ return m.group (1) + inner (m.group (2))
+ def inner (str):
+ str = 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, str)
+ return str
+ return inner (str)
+