X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=python%2Fconvertrules.py;h=7809041353a3f9d909cb7e15da1345b0159bc8a8;hb=7f34e80b8d8bebfa4b1f3721a12718b04d7e02f4;hp=aee0530e9c71e98297b468e33212b4126c88de42;hpb=7ede19c76ff88110e1af1975e33bc0041680a0b5;p=lilypond.git diff --git a/python/convertrules.py b/python/convertrules.py index aee0530e9c..7809041353 100644 --- a/python/convertrules.py +++ b/python/convertrules.py @@ -2846,7 +2846,7 @@ def conv(str): if re.search("(Slur|Tie)\w+#\'dash-fraction", str) \ or re.search("(Slur|Tie)\w+#\'dash-period", str): stderr_write (NOT_SMART % "dash-fraction, dash-period") - stderr_write (_ ("Dash parameters for slurs and ties are now in \'dash-details.\n")) + stderr_write (_ ("Dash parameters for slurs and ties are now in \'dash-definition.\n")) stderr_write (UPDATE_MANUALLY) return str @@ -3450,7 +3450,7 @@ def conv (str): 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)) @@ -3521,6 +3521,28 @@ def conv(str): 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): @@ -3581,6 +3603,132 @@ def conv(str): 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 + +@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 + +@rule ((2, 19, 12), "var #'prop ... = -> var.prop =") +def conv(str): + str = re.sub (r'(\s)(' + wordsyntax + r"(?:\s+#\s*'\s*" + + wordsyntax + r")+)(?=\s*=)", path_replace, 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,