+@rule ((2, 13, 40),
+ _ ("Remove \\paper variables head-separation and foot-separation."))
+def conv(str):
+ if re.search (r'head-separation', str):
+ 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', str):
+ stderr_write (NOT_SMART % "foot-separation")
+ stderr_write (_ ("Adjust settings for last-bottom-spacing instead.\n"))
+ stderr_write (UPDATE_MANUALLY);
+
+ return str
+
+@rule ((2, 13, 42),
+ _ ("Rename space to basic-distance in various spacing alists.\n\
+Remove HarmonicParenthesesItem grob."))
+def conv(str):
+ str = re.sub (r'\(space\s+\.\s+([0-9]*\.?[0-9]*)\)', r'(basic-distance . \1)', str)
+ str = re.sub (r"#'space\s+=\s+#?([0-9]*\.?[0-9]*)", r"#'basic-distance = #\1", str)
+ if re.search (r'HarmonicParenthesesItem', str):
+ 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 str
+
+@rule ((2, 13, 44),
+ _ ("Remove context from overrideTimeSignatureSettings and revertTimeSignatureSettings.\n"))
+
+def conv(str):
+ str = re.sub (r"\\(override|revert)TimeSignatureSettings(\s+[^#]*)(#[^#]*)#", r"\\\1TimeSignatureSettings\2#", str)
+ return str
+
+@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(str):
+ 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)) + ")"
+ str = re.sub (r"stringTunings\s*=\s*#'\(([\d\s-]*)\)", \
+ new_tunings , str)
+
+ str = re.sub (r"ukulele-(tenor|baritone)-tuning", r"\1-ukulele-tuning", str)
+
+ if re.search (r"[^-]page-top-space", str):
+ stderr_write (NOT_SMART % "page-top-space")
+ stderr_write (UPDATE_MANUALLY)
+ if re.search (r"[^-]between-system-(space|padding)", str):
+ stderr_write (NOT_SMART % "between-system-space, -padding")
+ stderr_write (UPDATE_MANUALLY)
+ if re.search (r"[^-](before|between|after)-title-space", str):
+ stderr_write (NOT_SMART % "before-, between-, after-title-space")
+ stderr_write (UPDATE_MANUALLY)
+ if re.search (r"\\name\s", str):
+ stderr_write ("\n" + _("Vertical spacing changes might affect user-defined contexts.") + "\n")
+ stderr_write (UPDATE_MANUALLY)
+
+ return str
+
+@rule ((2, 13, 48),
+ _ ("Replace bar-size with bar-extent."))
+
+def conv(str):
+ def size_as_extent (matchobj):
+ half = "%g" % (float (matchobj.group (1)) / 2)
+ return "bar-extent = #'(-" + half + " . " + half + ")"
+
+ str = re.sub (r"bar-size\s*=\s*#([0-9\.]+)", size_as_extent, str)
+
+ return str
+
+@rule ((2, 13, 51),
+ _ ("Woodwind diagrams: Changes to the clarinet diagram."))
+def conv(str):
+ if re.search (r'\\woodwind-diagram\s*#[^#]*clarinet\s', str):
+ stderr_write (NOT_SMART % "woodwind-diagrams")
+ stderr_write (_ ("Clarinet fingering changed to reflect actual anatomy of instrument.\n"))
+ stderr_write (UPDATE_MANUALLY)
+ return str
+
+@rule ((2, 14, 0),
+ _ ("bump version for release"))
+def conv (str):
+ return str
+
+@rule ((2, 15, 7),
+ _ ("Handling of non-automatic footnotes."))
+def conv(str):
+ if re.search (r'\\footnote', str):
+ 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 str
+
+@rule ((2, 15, 9),
+ _ ("Change in internal property for MultiMeasureRest"))
+def conv (str):
+ if re.search (r'use-breve-rest',str):
+ 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 str
+
+@rule ((2, 15, 10),
+ _ ("Creation of a Flag grob and moving of certain Stem properties to this grob"))
+def conv (str):
+ str = re.sub (r"Stem\s+#'flag-style", r"Flag #'style", str)
+ str = re.sub (r"Stem\s+#'stroke-style", r"Flag #'stroke-style", str)
+ str = re.sub (r"Stem\s+#'flag", r"Flag #'print", str)
+ str = 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", str)
+ str = re.sub (r"(\s+(?:\\once\s*)?)\\revert\s*Stem\s+#'transparent", r"\g<1>\\revert Stem #'transparent\g<1>\\revert Flag #'transparent", str)
+ str = 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", str)
+ str = re.sub (r"(\s+(?:\\once\s*)?)\\revert\s*Stem\s+#'stencil", r"\g<1>\\revert Stem #'stencil\g<1>\\revert Flag #'stencil", str)
+ return str
+
+@rule ((2, 15, 16), r"\makeStringTuning, \contextStringTuning -> \stringTuning")
+def conv (str):
+ str = 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>""",
+ str)
+ str = re.sub (r"""
+\\makeStringTuning(\s+)#'([-a-zA-Z]+)""",
+ r"""
+"\g<2>" = \\stringTuning""", str)
+ str = re.sub (r"\\makeStringTuning(\s+)#'([-a-zA-Z]+)(\s+<[^<>]+>)",
+ r"#(define \g<2> #{ \\stringTuning\g<3> #})", str)
+ return str
+
+@rule ((2, 15, 17), "\\markuplines -> \\markuplist\n\
+Change Beam broken slope syntax.")
+def conv (str):
+ str = re.sub (r"""
+\\markuplines( +)([^ ].*)
+ \1([^ ])""", r"""
+\\markuplist\g<1>\g<2>
+ \g<1>\g<3>""", str)
+ str = re.sub (r"\\markuplines", r"\\markuplist", str)
+ str = re.sub (r"@funindex markuplines", r"@funindex markuplist", str)
+ if re.search (r'consistent-broken-slope', str):
+ 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 str
+
+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
+ return
+
+def undollar_scm (m):
+ return re.sub (r"\$(.?)", r"\1", m.group (0))
+
+def undollar_embedded (m):
+ str = re.sub (r"#\$", "#", m.group (1))
+ # poor man's matched paren scanning after #, gives up
+ # after 25 levels.
+ str = re.sub ("#`?\("+paren_matcher (25)+"\)", undollar_scm, str)
+ return m.string[m.start (0):m.start (1)] + str + m.string[m.end (1):m.end (0)]
+
+def strip_export (str):
+ return re.sub (r"\(ly:export\s+(" + paren_matcher (25) + r")\)",
+ r"\1", str)
+
+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 (str):
+ str = re.sub (r"(?s)#@?\{(.*?)#@?\}", undollar_embedded, str)
+ str = re.sub (r"#\(define(?:-public)?\s+\(([-a-zA-Z]+)"
+ + r"\b[^()]*?\)(" + paren_matcher (25)
+ + r")\)", record_ugly, str)
+ str = re.sub (r"\(define(?:-public)?\s+\(" + should_really_be_music_function
+ + r"\b[^()]*\)(" + paren_matcher (25)
+ + r")\)", ugly_function_rewriter, str)
+ str = re.sub (r"#(?=\(" + should_really_be_music_function + ")", "$", str)
+ str = re.sub (r"#\(markup\*(?=\s)", r"$(markup", str)
+ str = re.sub ("#\("+paren_matcher (25)+"\)", export_puller, str)
+ if re.search (r"\(ly:export\s+", str):
+ stderr_write (NOT_SMART % "ly:export")
+ return str
+
+@rule ((2, 15, 19), r"$(set-time-signature ...) -> \time")
+def conv (str):
+ str = re.sub (r"\$\(set-time-signature\s+([0-9]+)\s+([0-9]+)\s*\)",
+ r"\\time \1/\2", str)
+ str = re.sub (r"\$\(set-time-signature\s+([0-9]+)\s+([0-9]+)\s+(" +
+ paren_matcher (5) + r")\)", r"\\time #\3 \1/\2", str)
+ if re.search (r"\(set-time-signature\s+", str):
+ stderr_write (NOT_SMART % "set-time-signature")
+ return str
+
+@rule ((2, 15, 20), r"$(set-accidental-style ...) -> \accidentalStyle")
+def conv (str):
+ str = re.sub (r"\$\(set-accidental-style\s+'([-a-z]+)\)",
+ r'\\accidentalStyle "\1"', str)
+ str = re.sub (r"\$\(set-accidental-style\s+'([-a-z]+)\s+'([-A-Za-z]+)\s*\)",
+ r'''\\accidentalStyle #'\2 "\1"''', str)
+ str = re.sub (r"(@funindex\s+)set-accidental-style",
+ r"\1\\accidentalStyle", str)
+ return str
+
+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]\S*|" + matchstring + r"|\("
+ + paren_matcher(20) + r"\))|" + matchstring + r"|\\[a-z_A-Z]+)")
+matchmarkup = (r'(?:\\markup\s*(?:{' + brace_matcher (20) +r'}|' +
+ matchstring + r'|(?:\\[a-z_A-Z][a-z_A-Z-]*(?:' + matcharg +
+ r')*?\s*)*(?:' + matchstring + "|{" + brace_matcher (20) +
+ "}))|" + matchstring + ")")
+
+@rule((2, 15, 25), r"\(auto)?Footnote(Grob)? -> \footnote")
+def conv (str):
+ # 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.
+ str = re.sub (r"\\footnote(" + matcharg + (r")(\s*" + matchmarkup)*2 + ")",
+ r"\\footnote\2\1\3", str)
+ str = re.sub (r"\\footnoteGrob"+("(" + matcharg + ")")*2 + r"(\s*" + matchmarkup + ")",
+ r"\\footnote\3\2\1", str)
+ str = re.sub (r"\\autoFootnoteGrob" + ("(" + matcharg + ")")*2,
+ r"\\footnote\2\1", str)
+ str = re.sub (r"\\autoFootnote",
+ r"\\footnote", str)
+ return str
+
+@rule((2, 15, 32), r"tempoWholesPerMinute -> \tempo")
+def conv (str):
+ 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)
+
+ str = re.sub (r"\\context\s*@?\{\s*\\Score\s+tempoWholesPerMinute\s*=\s*" +
+ r"#\(ly:make-moment\s+([0-9]+)\s+([0-9]+)\)\s*@?\}",
+ sub_tempo, str)
+ return str
+
+@rule((2, 15, 39), r"\footnote ... -> \footnote ... \default")
+def conv (str):
+ def not_first (s):
+ def match_fun (m):
+ if m.group (1):
+ return m.group (0)
+ return m.expand (s)
+ return match_fun
+ str = re.sub ("(" + matchmarkup + ")|"
+ + r"(\\footnote(?:\s*"
+ + matchmarkup + ")?" + matcharg + "(?:" + matcharg
+ + ")?\s+" + matchmarkup + ")",
+ not_first (r"\2 \\default"), str)
+ return str
+
+@rule ((2, 15, 40), r"Remove beamWholeMeasure")
+def conv (str):
+ if re.search (r"\bbeamWholeMeasure\b", str):
+ stderr_write (NOT_SMART % "beamWholeMeasure")
+ stderr_write (_ ("beamExceptions controls whole-measure beaming.") + "\n")
+ return str
+
+@rule ((2, 15, 42), r"\set stringTuning -> \set Staff.stringTuning")
+def conv (str):
+ str = re.sub (r"(\\set\s+)stringTuning", r"\1Staff.stringTuning", str)
+ return str
+
+wordsyntax = r"[a-zA-Z\200-\377](?:[-_]?[a-zA-Z\200-\377])*"
+
+@rule ((2, 15, 43), r'"custom-tuning" = -> custom-tuning =')
+def conv (str):
+ str = re.sub ('\n"(' + wordsyntax + r')"(\s*=\s*\\stringTuning)', "\n\\1\\2", str)
+ return str
+
+@rule ((2, 16, 0),
+ _ ("bump version for release"))
+def conv (str):
+ return str
+
+@rule ((2, 17, 0), r"blank-*-force -> blank-*-penalty")
+def conv (str):
+ str = re.sub ('blank-page-force', 'blank-page-penalty', str)
+ str = re.sub ('blank-last-page-force', 'blank-last-page-penalty', str)
+ str = re.sub ('blank-after-score-page-force', 'blank-after-score-page-penalty', str)
+ return str
+
+
+@rule ((2, 17, 4), r"\shape Grob #offsets -> \shape #offsets Grob")
+def conv (str):
+ str = re.sub (r"\\shape(\s+(?:[a-zA-Z]+|" + matchstring + "))(" +
+ matcharg + ")", r"\\shape\2\1", str)
+ return str
+
+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(str):
+ str = re.sub (barstring + r'"\|:"', '\\1\\2".|:"', str)
+ str = re.sub (barstring + r'":\|"', '\\1\\2":|."', str)
+ str = re.sub (barstring + r'"\|\|:"', '\\1\\2".|:-||"', str)
+ str = re.sub (barstring + r'":\|:"', '\\1\\2":..:"', str)
+ str = re.sub (barstring + r'"\.\|\."', '\\1\\2".."', str)
+ str = re.sub (barstring + r'"\|S"', '\\1\\2"S-|"', str)
+ str = re.sub (barstring + r'"S\|"', '\\1\\2"S-S"', str)
+ str = re.sub (barstring + r'":\|S"', '\\1\\2":|.S"', str)
+ str = re.sub (barstring + r'":\|S\."', '\\1\\2":|.S-S"', str)
+ str = re.sub (barstring + r'"S\|:"', '\\1\\2"S.|:-S"', str)
+ str = re.sub (barstring + r'"\.S\|:"', '\\1\\2"S.|:"', str)
+ str = re.sub (barstring + r'":\|S\|:"', '\\1\\2":|.S.|:"', str)
+ str = re.sub (barstring + r'":\|S\.\|:"', '\\1\\2":|.S.|:-S"', str)
+ str = re.sub (barstring + r'":"', '\\1\\2";"', str)
+ str = re.sub (barstring + r'"\|s"', '\\1\\2"|-s"', str)
+ str = re.sub (barstring + r'"dashed"', '\\1\\2"!"', str)
+ str = re.sub (barstring + r'"kievan"', '\\1\\2"k"', str)
+ str = re.sub (barstring + r'"empty"', '\\1\\2"-"', str)
+ return str
+
+symbol_list = (r"#'(?:" + wordsyntax + r"|\(\s*(?:" + wordsyntax + r"\s+)*"
+ + wordsyntax + r"\s*\))")
+
+grob_path = r"(?:" + symbol_list + r"\s+)*" + symbol_list
+
+grob_spec = wordsyntax + r"(?:\s*\.\s*" + wordsyntax + r")?"
+
+def path_replace (m):
+ return m.group (1) + string.join (re.findall (wordsyntax, m.group (2)), ".")
+
+@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 (str):
+ def patrep (m):
+ def fn_path_replace (m):
+ x = string.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
+
+ str = re.sub (r'''(\\accidentalStyle\s+)#?"([-A-Za-z]+)"''',
+ r"\1\2", str)
+ str = re.sub (r'''(\\accidentalStyle\s+)#'([A-Za-z]+)\s+#?"?([-A-Za-z]+)"?''',
+ r"\1\2.\3", str)
+ str = re.sub (r'''(\\(?:alterBroken|overrideProperty)\s+)#?"([A-Za-z]+)\s*\.\s*([A-Za-z]+)"''',
+ r"\1\2.\3", str)
+ str = re.sub (r'''(\\tweak\s+)#?"?([A-Za-z]+)"?\s+?#'([-A-Za-z]+)''',
+ r"\1\2.\3", str)
+ str = re.sub (r'''(\\tweak\s+)#'([-A-Za-z]+)''',
+ r"\1\2", str)
+ str = re.sub ("(" + matchmarkup + ")|"
+ + r"(\\footnote(?:\s*"
+ + matchmarkup + ")?" + matcharg + ")(" + matcharg
+ + r")?(\s+" + matchmarkup + r")(\s+\\default)?",
+ patrep, str)
+ str = re.sub (r'''(\\alterBroken)(\s+[A-Za-z.]+)(''' + matcharg
+ + matcharg + ")", r"\1\3\2", str)
+ str = re.sub (r"(\\overrideProperty\s+)(" + grob_spec + r"\s+" + grob_path + ")",
+ path_replace, str)
+ str = re.sub (r"(\\(?:override|revert)\s+)(" + grob_spec + r"\s+" + grob_path + ")",
+ path_replace, str)
+ return str