r"\1/\2", str)
return str
+@rule((2, 17, 14), r"\accepts ... -> \accepts ... \defaultchild ...")
+def conv(str):
+ 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)
+
+ str = re.sub (r"\\context\s*@?\{(" + brace_matcher (20) + ")\}",
+ matchaccepts, str)
+ return str
+
@rule((2, 17, 15), r"""#(ly:set-option 'old-relative)
\relative -> \relative c'""")
def conv(str):
str = re.sub ('cueClefOctavationStyle', 'cueClefTranspositionStyle', str)
return str
+@rule((2, 17, 19), r"\column { \vspace #2 } -> \column { \combine \null \vspace #2 }")
+def conv(str):
+ 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.
+
+ str = re.sub (r"(\\\\?)vspace(\s)", r"\1combine \1null \1vspace\2", m.group(0))
+ return str
+
+ str = re.sub (r"\\(?:left-|right-|center-|)column\s*\{" + brace_matcher (20) + r"\}",
+ vspace_replace, str)
+ return str
+
+@rule((2, 17, 20), _(r"Flag.transparent and Flag.color inherit from Stem"))
+def conv(str):
+ str = 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", str)
+ str = re.sub (r"(((?:\\once\s*)?)\\revert\s+((?:\w+\.)?)Stem\.(transparent|color))\s+\2\\revert\s+\3Flag\.\4",
+ r"\1", str)
+ str = re.sub (r"(\\tweak\s+((?:\w+\.)?)Stem\.(transparent|color)\s+(#\S+))\s+\\tweak\s+\2Flag\.\3\s+\4",
+ r"\1", str)
+ return str
+
+@rule((2, 17, 25), r'''\tempo 4. = 50~60 -> \tempo 4. = 50-60
+-| -> -!
+pipeSymbol, escapedParenthesisOpenSymbol ... -> "|", "\\(" ...''')
+def conv(str):
+# 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
+ str = re.sub (r"(=\s*[0-9]+\s*)~(\s*[0-9]+\s)", r"\1-\2", str)
+# 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)
+ str = re.sub (r"([-^_])\||" + matchstring + r"|[-^_][-^_]", subnonstring, str)
+ str = re.sub (r"\bdashBar\b", "dashBang", str)
+ 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]) + '"'
+ str = re.sub (words + "|" + matchstring, wordreplace, str)
+ return str
+
+@rule((2, 17, 27), r'''\stringTuning \notemode -> \stringTuning''')
+def conv(str):
+ str = re.sub (r"\\stringTuning\s*\\notemode(\s*)@?\{\s*(.*?)\s*@?}",
+ r"\\stringTuning\1\2", str)
+ if re.search (r'[^-\w]staff-padding[^-\w]', str):
+ stderr_write (NOT_SMART % "staff-padding")
+ stderr_write (_ ("Staff-padding now controls the distance to the baseline, not the nearest point."))
+ return str
+
+@rule((2, 17, 29), r'''Dynamic_engraver -> New_dynamic_engraver+Dynamic_align_engraver
+New_dynamic_engraver -> Dynamic_engraver''')
+def conv(str):
+ str = re.sub ("(\r?\n?[ \t]*\\\\(?:consists|remove)\\s*)(\"?)Dynamic_engraver\\2",
+ r"\1\2New_dynamic_engraver\2\1\2Dynamic_align_engraver\2",
+ str)
+# Should we warn about any remaining Dynamic_engraver? Possibly it
+# will do the job just fine.
+ str = re.sub ("New_dynamic_engraver", "Dynamic_engraver", str)
+ return str
+
+@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
+
# 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,