python/convertrules.py

   1 import string
   2 import re
   3 import sys
   4 import lilylib
   5
   6 _ = lilylib._
   7
   8
   9 NOT_SMART = _ ("Not smart enough to convert %s")
  10 UPDATE_MANUALLY = _ ("Please refer to the manual for details, and update manually.")
  11 FROM_TO = _ ( "%s has been replaced by %s")
  12
  13
  14 class FatalConversionError:
  15         pass
  16
  17 conversions = []
  18
  19 error_file = sys.stderr
  20 lilypond_version_re_str = '\\\\version *\"([^"]+)\"'
  21 lilypond_version_re = re.compile (lilypond_version_re_str)
  22
  23
  24
  25
  26 def conv(str):
  27         if re.search ('\\\\multi', str):
  28                 error_file.write ('\n')
  29                 error_file.write (NOT_SMART % "\\multi")
  30                 error_file.write ('\n')
  31         return str
  32
  33 conversions.append (((0,1,9), conv, '\\header { key = concat + with + operator }'))
  34
  35
  36 def conv (str):
  37         if re.search ('\\\\octave', str):
  38                 error_file.write ('\n')
  39                 error_file.write (NOT_SMART % "\\octave")
  40                 error_file.write ('\n')
  41                 error_file.write (UPDATE_MANUALLY)
  42                 error_file.write ('\n')
  43         #       raise FatalConversionError ()
  44
  45         return str
  46
  47 conversions.append ((
  48         ((0,1,19), conv, 'deprecated \\octave; cannot convert automatically')))
  49
  50
  51
  52 def conv (str):
  53         str = re.sub ('\\\\textstyle([^;]+);',
  54                                  '\\\\property Lyrics . textstyle = \\1', str)
  55         # harmful to current .lys
  56         # str = re.sub ('\\\\key([^;]+);', '\\\\accidentals \\1;', str)
  57
  58         return str
  59
  60 conversions.append ((
  61         ((0,1,20), conv, 'deprecated \\textstyle, new \\key syntax')))
  62
  63
  64
  65 def conv (str):
  66         str = re.sub ('\\\\musical_pitch', '\\\\musicalpitch',str)
  67         str = re.sub ('\\\\meter', '\\\\time',str)
  68
  69         return str
  70
  71 conversions.append ((
  72         ((0,1,21), conv, '\\musical_pitch -> \\musicalpitch, '+
  73          '\\meter -> \\time')))
  74
  75
  76 def conv (str):
  77         return str
  78
  79 conversions.append ((
  80         ((1,0,0), conv, '0.1.21 -> 1.0.0 ')))
  81
  82
  83
  84 def conv (str):
  85         str = re.sub ('\\\\accidentals', '\\\\keysignature',str)
  86         str = re.sub ('specialaccidentals *= *1', 'keyoctaviation = 0',str)
  87         str = re.sub ('specialaccidentals *= *0', 'keyoctaviation = 1',str)
  88
  89         return str
  90
  91 conversions.append ((
  92         ((1,0,1), conv, '\\accidentals -> \\keysignature, ' +
  93          'specialaccidentals -> keyoctaviation')))
  94
  95
  96 def conv(str):
  97         if re.search ('\\\\header', str):
  98                 error_file.write ('\n')
  99                 error_file.write (NOT_SMART % "new \\header format")
 100                 error_file.write ('\n')
 101         return str
 102
 103 conversions.append (((1,0,2), conv, '\\header { key = concat + with + operator }'))
 104
 105
 106 def conv(str):
 107         str =  re.sub ('\\\\melodic([^a-zA-Z])', '\\\\notes\\1',str)
 108         return str
 109
 110 conversions.append (((1,0,3), conv, '\\melodic -> \\notes'))
 111
 112
 113 def conv(str):
 114         str =  re.sub ('default_paper *=', '',str)
 115         str =  re.sub ('default_midi *=', '',str)
 116         return str
 117
 118 conversions.append (((1,0,4), conv, 'default_{paper,midi}'))
 119
 120
 121 def conv(str):
 122         str =  re.sub ('ChoireStaff', 'ChoirStaff',str)
 123         str =  re.sub ('\\\\output', 'output = ',str)
 124
 125         return str
 126
 127 conversions.append (((1,0,5), conv, 'ChoireStaff -> ChoirStaff'))
 128
 129
 130 def conv(str):
 131         if re.search ('[a-zA-Z]+ = *\\translator',str):
 132                 error_file.write ('\n')
 133                 error_file.write (NOT_SMART % "\\translator syntax")
 134                 error_file.write ('\n')
 135         #       raise FatalConversionError ()
 136         return str
 137
 138 conversions.append (((1,0,6), conv, 'foo = \\translator {\\type .. } ->\\translator {\\type ..; foo; }'))
 139
 140
 141
 142 def conv(str):
 143         str =  re.sub ('\\\\lyrics*', '\\\\lyrics',str)
 144
 145         return str
 146
 147 conversions.append (((1,0,7), conv, '\\lyric -> \\lyrics'))
 148
 149
 150 def conv(str):
 151         str =  re.sub ('\\\\\\[/3+', '\\\\times 2/3 { ',str)
 152         str =  re.sub ('\\[/3+', '\\\\times 2/3 { [',str)
 153         str =  re.sub ('\\\\\\[([0-9/]+)', '\\\\times \\1 {',str)
 154         str =  re.sub ('\\[([0-9/]+)', '\\\\times \\1 { [',str)
 155         str =  re.sub ('\\\\\\]([0-9/]+)', '}', str)
 156         str =  re.sub ('\\\\\\]', '}',str)
 157         str =  re.sub ('\\]([0-9/]+)', '] }', str)
 158         return str
 159
 160 conversions.append (((1,0,10), conv, '[2/3 ]1/1 -> \\times 2/3 '))
 161
 162
 163 def conv(str):
 164         return str
 165 conversions.append (((1,0,12), conv, 'Chord syntax stuff'))
 166
 167
 168
 169 def conv(str):
 170
 171
 172         str =  re.sub ('<([^>~]+)~([^>]*)>','<\\1 \\2> ~', str)
 173
 174         return str
 175
 176 conversions.append (((1,0,13), conv, '<a ~ b> c -> <a b> ~ c'))
 177
 178
 179 def conv(str):
 180         str =  re.sub ('<\\[','[<', str)
 181         str =  re.sub ('\\]>','>]', str)
 182
 183         return str
 184
 185 conversions.append (((1,0,14), conv, '<[a b> <a b]>c -> [<a b> <a b>]'))
 186
 187
 188
 189 def conv(str):
 190         str =  re.sub ('\\\\type([^\n]*engraver)','\\\\TYPE\\1', str)
 191         str =  re.sub ('\\\\type([^\n]*performer)','\\\\TYPE\\1', str)
 192         str =  re.sub ('\\\\type','\\\\context', str)
 193         str =  re.sub ('\\\\TYPE','\\\\type', str)
 194         str =  re.sub ('textstyle','textStyle', str)
 195
 196         return str
 197
 198 conversions.append (((1,0,16), conv, '\\type -> \\context, textstyle -> textStyle'))
 199
 200
 201
 202 def conv(str):
 203         if re.search ('\\\\repeat',str):
 204                 error_file.write ('\n')
 205                 error_file.write (NOT_SMART % "\\repeat")
 206                 error_file.write ('\n')
 207         #       raise FatalConversionError ()
 208         return str
 209
 210 conversions.append (((1,0,18), conv,
 211                      '\\repeat NUM Music Alternative -> \\repeat FOLDSTR Music Alternative'))
 212
 213
 214 def conv(str):
 215         str =  re.sub ('SkipBars','skipBars', str)
 216         str =  re.sub ('fontsize','fontSize', str)
 217         str =  re.sub ('midi_instrument','midiInstrument', str)
 218
 219         return str
 220
 221 conversions.append (((1,0,19), conv,
 222                      'fontsize -> fontSize, midi_instrument -> midiInstrument, SkipBars -> skipBars'))
 223
 224
 225
 226 def conv(str):
 227         str =  re.sub ('tieydirection','tieVerticalDirection', str)
 228         str =  re.sub ('slurydirection','slurVerticalDirection', str)
 229         str =  re.sub ('ydirection','verticalDirection', str)
 230
 231         return str
 232
 233 conversions.append (((1,0,20), conv,
 234         '{,tie,slur}ydirection -> {v,tieV,slurV}erticalDirection'))
 235
 236
 237
 238 def conv(str):
 239         str =  re.sub ('hshift','horizontalNoteShift', str)
 240
 241         return str
 242
 243 conversions.append (((1,0,21), conv,
 244         'hshift -> horizontalNoteShift'))
 245
 246
 247
 248 def conv(str):
 249         str =  re.sub ('\\\\grouping[^;]*;','', str)
 250
 251         return str
 252
 253 conversions.append (((1,1,52), conv,
 254         'deprecate \\grouping'))
 255
 256
 257
 258 def conv(str):
 259         str =  re.sub ('\\\\wheel','\\\\coda', str)
 260
 261         return str
 262
 263 conversions.append (((1,1,55), conv,
 264         '\\wheel -> \\coda'))
 265
 266
 267 def conv(str):
 268         str =  re.sub ('keyoctaviation','keyOctaviation', str)
 269         str =  re.sub ('slurdash','slurDash', str)
 270
 271         return str
 272
 273 conversions.append (((1,1,65), conv,
 274         'slurdash -> slurDash, keyoctaviation -> keyOctaviation'))
 275
 276
 277 def conv(str):
 278         str =  re.sub ('\\\\repeat *\"?semi\"?','\\\\repeat "volta"', str)
 279
 280         return str
 281
 282 conversions.append (((1,1,66), conv,
 283         'semi -> volta'))
 284
 285
 286
 287 def conv(str):
 288         str =  re.sub ('\"?beamAuto\"? *= *\"?0?\"?','noAutoBeaming = "1"', str)
 289
 290         return str
 291
 292 conversions.append (((1,1,67), conv,
 293         'beamAuto -> noAutoBeaming'))
 294
 295
 296 def conv(str):
 297         str =  re.sub ('automaticMelismas', 'automaticMelismata', str)
 298
 299         return str
 300
 301 conversions.append (((1,2,0), conv,
 302         'automaticMelismas -> automaticMelismata'))
 303
 304
 305 def conv(str):
 306         str =  re.sub ('dynamicDir\\b', 'dynamicDirection', str)
 307
 308         return str
 309
 310 conversions.append (((1,2,1), conv,
 311         'dynamicDir -> dynamicDirection'))
 312
 313
 314 def conv(str):
 315         str =  re.sub ('\\\\cadenza *0 *;', '\\\\cadenzaOff', str)
 316         str =  re.sub ('\\\\cadenza *1 *;', '\\\\cadenzaOn', str)
 317
 318         return str
 319
 320 conversions.append (((1,3,4), conv,
 321         '\\cadenza -> \\cadenza{On|Off}'))
 322
 323
 324 def conv (str):
 325         str = re.sub ('"?beamAuto([^"=]+)"? *= *"([0-9]+)/([0-9]+)" *;*',
 326                       'beamAuto\\1 = #(make-moment \\2 \\3)',
 327                       str)
 328         return str
 329
 330 conversions.append (((1,3,5), conv, 'beamAuto moment properties'))
 331
 332
 333 def conv (str):
 334         str = re.sub ('stemStyle',
 335                       'flagStyle',
 336                       str)
 337         return str
 338
 339 conversions.append (((1,3,17), conv, 'stemStyle -> flagStyle'))
 340
 341
 342 def conv (str):
 343         str = re.sub ('staffLineLeading',
 344                       'staffSpace',
 345                       str)
 346         return str
 347
 348 conversions.append (((1,3,18), conv, 'staffLineLeading -> staffSpace'))
 349
 350
 351
 352 def conv(str):
 353         if re.search ('\\\\repetitions',str):
 354                 error_file.write ('\n')
 355                 error_file.write (NOT_SMART % "\\repetitions")
 356                 error_file.write ('\n')
 357         #       raise FatalConversionError ()
 358         return str
 359
 360 conversions.append (((1,3,23), conv,
 361         '\\\\repetitions feature dropped'))
 362
 363
 364
 365 def conv (str):
 366         str = re.sub ('textEmptyDimension *= *##t',
 367                       'textNonEmpty = ##f',
 368                       str)
 369         str = re.sub ('textEmptyDimension *= *##f',
 370                       'textNonEmpty = ##t',
 371                       str)
 372         return str
 373
 374 conversions.append (((1,3,35), conv, 'textEmptyDimension -> textNonEmpty'))
 375
 376
 377 def conv (str):
 378         str = re.sub ("([a-z]+)[ \t]*=[ \t]*\\\\musicalpitch *{([- 0-9]+)} *\n",
 379                       "(\\1 . (\\2))\n", str)
 380         str = re.sub ("\\\\musicalpitch *{([0-9 -]+)}",
 381                       "\\\\musicalpitch #'(\\1)", str)
 382         if re.search ('\\\\notenames',str):
 383                 error_file.write ('\n')
 384                 error_file.write (NOT_SMART % "new \\notenames format")
 385                 error_file.write ('\n')
 386         return str
 387
 388 conversions.append (((1,3,38), conv, '\musicalpitch { a b c } -> #\'(a b c)'))
 389
 390
 391 def conv (str):
 392         def replace (match):
 393                 return '\\key %s;' % string.lower (match.group (1))
 394
 395         str = re.sub ("\\\\key ([^;]+);",  replace, str)
 396         return str
 397
 398 conversions.append (((1,3,39), conv, '\\key A ;  ->\\key a;'))
 399
 400
 401 def conv (str):
 402         if re.search ('\\[:',str):
 403                 error_file.write ('\n')
 404                 error_file.write (NOT_SMART % "new tremolo format")
 405                 error_file.write ('\n')
 406         return str
 407
 408 conversions.append (((1,3,41), conv,
 409         '[:16 c4 d4 ] -> \\repeat "tremolo" 2 { c16 d16 }'))
 410
 411
 412 def conv (str):
 413         str = re.sub ('Staff_margin_engraver' , 'Instrument_name_engraver', str)
 414         return str
 415
 416 conversions.append (((1,3,42), conv,
 417         'Staff_margin_engraver deprecated, use Instrument_name_engraver'))
 418
 419
 420 def conv (str):
 421         str = re.sub ('note[hH]eadStyle\\s*=\\s*"?(\\w+)"?' , "noteHeadStyle = #'\\1", str)
 422         return str
 423
 424 conversions.append (((1,3,49), conv,
 425         'noteHeadStyle value: string -> symbol'))
 426
 427
 428 def conv (str):
 429         if re.search ('\\\\keysignature', str):
 430                 error_file.write ('\n')
 431                 error_file.write (NOT_SMART % "new tremolo format")
 432                 error_file.write ('\n')
 433         return str
 434
 435
 436 conversions.append (((1,3,58), conv,
 437         'noteHeadStyle value: string -> symbol'))
 438
 439
 440 def conv (str):
 441         str = re.sub (r"""\\key *([a-z]+) *;""", r"""\\key \1 \major;""",str);
 442         return str
 443 conversions.append (((1,3,59), conv,
 444         '\key X ; -> \key X major; '))
 445
 446
 447 def conv (str):
 448         str = re.sub (r'latexheaders *= *"\\\\input ',
 449                       'latexheaders = "',
 450                       str)
 451         return str
 452 conversions.append (((1,3,68), conv, 'latexheaders = "\\input global" -> latexheaders = "global"'))
 453
 454
 455
 456
 457 # TODO: lots of other syntax change should be done here as well
 458
 459 def conv (str):
 460         str = re.sub ('basicCollisionProperties', 'NoteCollision', str)
 461         str = re.sub ('basicVoltaSpannerProperties' , "VoltaBracket", str)
 462         str = re.sub ('basicKeyProperties' , "KeySignature", str)
 463
 464         str = re.sub ('basicClefItemProperties' ,"Clef", str)
 465
 466
 467         str = re.sub ('basicLocalKeyProperties' ,"Accidentals", str)
 468         str = re.sub ('basicMarkProperties' ,"Accidentals", str)
 469         str = re.sub ('basic([A-Za-z_]+)Properties', '\\1', str)
 470
 471         str = re.sub ('Repeat_engraver' ,'Volta_engraver', str)
 472         return str
 473
 474 conversions.append (((1,3,92), conv, 'basicXXXProperties -> XXX, Repeat_engraver -> Volta_engraver'))
 475
 476
 477 def conv (str):
 478         # Ugh, but meaning of \stemup changed too
 479         # maybe we should do \stemup -> \stemUp\slurUp\tieUp ?
 480         str = re.sub ('\\\\stemup', '\\\\stemUp', str)
 481         str = re.sub ('\\\\stemdown', '\\\\stemDown', str)
 482         str = re.sub ('\\\\stemboth', '\\\\stemBoth', str)
 483
 484         str = re.sub ('\\\\slurup', '\\\\slurUp', str)
 485         str = re.sub ('\\\\slurboth', '\\\\slurBoth', str)
 486         str = re.sub ('\\\\slurdown', '\\\\slurDown', str)
 487         str = re.sub ('\\\\slurdotted', '\\\\slurDotted', str)
 488         str = re.sub ('\\\\slurnormal', '\\\\slurNoDots', str)
 489
 490         str = re.sub ('\\\\shiftoff', '\\\\shiftOff', str)
 491         str = re.sub ('\\\\shifton', '\\\\shiftOn', str)
 492         str = re.sub ('\\\\shiftonn', '\\\\shiftOnn', str)
 493         str = re.sub ('\\\\shiftonnn', '\\\\shiftOnnn', str)
 494
 495         str = re.sub ('\\\\onevoice', '\\\\oneVoice', str)
 496         str = re.sub ('\\\\voiceone', '\\\\voiceOne', str)
 497         str = re.sub ('\\\\voicetwo', '\\\\voiceTwo', str)
 498         str = re.sub ('\\\\voicethree', '\\\\voiceThree', str)
 499         str = re.sub ('\\\\voicefour', '\\\\voiceFour', str)
 500
 501         # I don't know exactly when these happened...
 502         # ugh, we loose context setting here...
 503         str = re.sub ('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\\\stemUp\\\\slurUp\\\\tieUp', str)
 504         str = re.sub ('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?', '\\\\stemDown\\\\slurDown\\\\tieDown', str)
 505         str = re.sub ('\\\\property *[^ ]*verticalDirection[^=]*= *#?"?(0|(\\\\center))"?', '\\\\stemBoth\\\\slurBoth\\\\tieBoth', str)
 506
 507         str = re.sub ('verticalDirection[^=]*= *#?"?(1|(\\\\up))"?', 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #1', str)
 508         str = re.sub ('verticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?', 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #-1', str)
 509         str = re.sub ('verticalDirection[^=]*= *#?"?(0|(\\\\center))"?', 'Stem \\\\override #\'direction = #0\nSlur \\\\override #\'direction = #0\n Tie \\\\override #\'direction = #0', str)
 510
 511         str = re.sub ('\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\\\\\1Up', str)
 512         str = re.sub ('\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?', '\\\\\\1Down', str)
 513         str = re.sub ('\\\\property *[^ .]*[.]?([a-z]+)VerticalDirection[^=]*= *#?"?(0|(\\\\center))"?', '\\\\\\1Both', str)
 514
 515         # (lacks capitalisation slur -> Slur)
 516         str = re.sub ('([a-z]+)VerticalDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\1 \\\\override #\'direction = #1', str)
 517         str = re.sub ('([a-z]+)VerticalDirection[^=]*= *#?"?((-1)|(\\\\down))"?', '\\1 \\override #\'direction = #-1', str)
 518         str = re.sub ('([a-z]+)VerticalDirection[^=]*= *#?"?(0|(\\\\center))"?', '\\1 \\\\override #\'direction = #0', str)
 519
 520         ## dynamic..
 521         str = re.sub ('\\\\property *[^ .]*[.]?dynamicDirection[^=]*= *#?"?(1|(\\\\up))"?', '\\\\dynamicUp', str)
 522         str = re.sub ('\\\\property *[^ .]*[.]?dyn[^=]*= *#?"?((-1)|(\\\\down))"?', '\\\\dynamicDown', str)
 523         str = re.sub ('\\\\property *[^ .]*[.]?dyn[^=]*= *#?"?(0|(\\\\center))"?', '\\\\dynamicBoth', str)
 524
 525         str = re.sub ('\\\\property *[^ .]*[.]?([a-z]+)Dash[^=]*= *#?"?(0|(""))"?', '\\\\\\1NoDots', str)
 526         str = re.sub ('\\\\property *[^ .]*[.]?([a-z]+)Dash[^=]*= *#?"?([1-9]+)"?', '\\\\\\1Dotted', str)
 527
 528         str = re.sub ('\\\\property *[^ .]*[.]?noAutoBeaming[^=]*= *#?"?(0|(""))"?', '\\\\autoBeamOn', str)
 529         str = re.sub ('\\\\property *[^ .]*[.]?noAutoBeaming[^=]*= *#?"?([1-9]+)"?', '\\\\autoBeamOff', str)
 530
 531
 532
 533         return str
 534
 535 conversions.append (((1,3,93), conv,
 536         'property definiton case (eg. onevoice -> oneVoice)'))
 537
 538
 539
 540 def conv (str):
 541         str = re.sub ('ChordNames*', 'ChordNames', str)
 542         if re.search ('\\\\textscript "[^"]* *"[^"]*"', str):
 543                 error_file.write ('\n')
 544                 error_file.write (NOT_SMART % "new \\textscript markup text")
 545                 error_file.write ('\n')
 546
 547         str = re.sub ('\\textscript +("[^"]*")', '\\textscript #\\1', str)
 548
 549         return str
 550
 551 conversions.append (((1,3,97), conv, 'ChordName -> ChordNames'))
 552
 553
 554 # TODO: add lots of these
 555
 556
 557 def conv (str):
 558         str = re.sub ('\\\\property *"?Voice"? *[.] *"?textStyle"? *= *"([^"]*)"', '\\\\property Voice.TextScript \\\\set #\'font-style = #\'\\1', str)
 559         str = re.sub ('\\\\property *"?Lyrics"? *[.] *"?textStyle"? *= *"([^"]*)"', '\\\\property Lyrics.LyricText \\\\set #\'font-style = #\'\\1', str)
 560
 561         str = re.sub ('\\\\property *"?([^.]+)"? *[.] *"?timeSignatureStyle"? *= *"([^"]*)"', '\\\\property \\1.TimeSignature \\\\override #\'style = #\'\\2', str)
 562
 563         str = re.sub ('"?timeSignatureStyle"? *= *#?""', 'TimeSignature \\\\override #\'style = ##f', str)
 564
 565         str = re.sub ('"?timeSignatureStyle"? *= *#?"([^"]*)"', 'TimeSignature \\\\override #\'style = #\'\\1', str)
 566
 567         str = re.sub ('#\'style *= #*"([^"])"', '#\'style = #\'\\1', str)
 568
 569         str = re.sub ('\\\\property *"?([^.]+)"? *[.] *"?horizontalNoteShift"? *= *"?#?([-0-9]+)"?', '\\\\property \\1.NoteColumn \\\\override #\'horizontal-shift = #\\2', str)
 570
 571         # ugh
 572         str = re.sub ('\\\\property *"?([^.]+)"? *[.] *"?flagStyle"? *= *""', '\\\\property \\1.Stem \\\\override #\'flag-style = ##f', str)
 573
 574         str = re.sub ('\\\\property *"?([^.]+)"? *[.] *"?flagStyle"? *= *"([^"]*)"', '\\\\property \\1.Stem \\\\override #\'flag-style = #\'\\2', str)
 575         return str
 576
 577 conversions.append (((1,3,98), conv, 'CONTEXT.textStyle -> GROB.#font-style '))
 578
 579
 580 def conv (str):
 581         str = re.sub ('"?beamAutoEnd_([0-9]*)"? *= *(#\\([^)]*\\))', 'autoBeamSettings \\push #\'(end 1 \\1 * *) = \\2', str)
 582         str = re.sub ('"?beamAutoBegin_([0-9]*)"? *= *(#\\([^)]*\))', 'autoBeamSettings \\push #\'(begin 1 \\1 * *) = \\2', str)
 583         str = re.sub ('"?beamAutoEnd"? *= *(#\\([^)]*\\))', 'autoBeamSettings \\push #\'(end * * * *) = \\1', str)
 584         str = re.sub ('"?beamAutoBegin"? *= *(#\\([^)]*\\))', 'autoBeamSettings \\push #\'(begin * * * *) = \\1', str)
 585
 586
 587         return str
 588
 589 conversions.append (((1,3,102), conv, 'beamAutoEnd -> autoBeamSettings \\push (end * * * *)'))
 590
 591
 592
 593 def conv (str):
 594         str = re.sub ('\\\\push', '\\\\override', str)
 595         str = re.sub ('\\\\pop', '\\\\revert', str)
 596
 597         return str
 598
 599 conversions.append (((1,3,111), conv, '\\push -> \\override, \\pop -> \\revert'))
 600
 601
 602 def conv (str):
 603         str = re.sub ('LyricVoice', 'LyricsVoice', str)
 604         # old fix
 605         str = re.sub ('Chord[Nn]ames*.Chord[Nn]ames*', 'ChordNames.ChordName', str)
 606         str = re.sub ('Chord[Nn]ames([ \t\n]+\\\\override)', 'ChordName\\1', str)
 607         return str
 608
 609 conversions.append (((1,3,113), conv, 'LyricVoice -> LyricsVoice'))
 610
 611 def conv (str):
 612         def regularize_id (str):
 613                 s = ''
 614                 lastx = ''
 615                 for x in str:
 616                         if x == '_':
 617                                 lastx = x
 618                                 continue
 619                         elif x in string.digits:
 620                                 x = chr(ord (x) - ord ('0')  +ord ('A'))
 621                         elif x not in string.letters:
 622                                 x = 'x'
 623                         elif x in string.lowercase and lastx == '_':
 624                                 x = string.upper (x)
 625                         s = s + x
 626                         lastx = x
 627                 return s
 628
 629                 def regularize_dollar_reference (match):
 630                         return regularize_id (match.group (1))
 631                 def regularize_assignment (match):
 632                         return '\n' + regularize_id (match.group (1)) + ' = '
 633                 str = re.sub ('\$([^\t\n ]+)', regularize_dollar_reference, str)
 634                 str = re.sub ('\n([^ \t\n]+)[ \t]*= *', regularize_assignment, str)
 635                 return str
 636
 637 conversions.append (((1,3,117), conv, 'identifier names: $!foo_bar_123 -> xfooBarABC'))
 638
 639
 640
 641 def conv (str):
 642         def regularize_paper (match):
 643                 return regularize_id (match.group (1))
 644
 645         str = re.sub ('(paper_[a-z]+)', regularize_paper, str)
 646         str = re.sub ('sustainup', 'sustainUp', str)
 647         str = re.sub ('nobreak', 'noBreak', str)
 648         str = re.sub ('sustaindown', 'sustainDown', str)
 649         str = re.sub ('sostenutoup', 'sostenutoUp', str)
 650         str = re.sub ('sostenutodown', 'sostenutoDown', str)
 651         str = re.sub ('unachorda', 'unaChorda', str)
 652         str = re.sub ('trechorde', 'treChorde', str)
 653
 654         return str
 655
 656 conversions.append (((1,3,120), conv, 'paper_xxx -> paperXxxx, pedalup -> pedalUp.'))
 657
 658
 659 def conv (str):
 660         str = re.sub ('drarnChords', 'chordChanges', str)
 661         str = re.sub ('\\musicalpitch', '\\pitch', str)
 662         return str
 663
 664 conversions.append (((1,3,122), conv, 'drarnChords -> chordChanges, \\musicalpitch -> \\pitch'))
 665
 666
 667 def conv (str):
 668         str = re.sub ('ly-([sg])et-elt-property', 'ly-\\1et-grob-property', str)
 669         return str
 670
 671 conversions.append (((1,3,136), conv, 'ly-X-elt-property -> ly-X-grob-property'))
 672
 673
 674 def conv (str):
 675         str = re.sub ('point-and-click +#t', 'point-and-click line-column-location', str)
 676         return str
 677
 678 conversions.append (((1,3,138), conv, 'point-and-click argument changed to procedure.'))
 679
 680
 681 def conv (str):
 682         str = re.sub ('followThread', 'followVoice', str)
 683         str = re.sub ('Thread.FollowThread', 'Voice.VoiceFollower', str)
 684         str = re.sub ('FollowThread', 'VoiceFollower', str)
 685         return str
 686
 687 conversions.append (((1,3,138), conv, 'followThread -> followVoice.'))
 688
 689
 690 def conv (str):
 691         str = re.sub ('font-point-size', 'font-design-size', str)
 692         return str
 693
 694 conversions.append (((1,3,139), conv, 'font-point-size -> font-design-size.'))
 695
 696
 697 def conv (str):
 698         str = re.sub ('([a-zA-Z]*)NoDots', '\\1Solid', str)
 699         return str
 700
 701 conversions.append (((1,3,141), conv, 'xNoDots -> xSolid'))
 702
 703
 704 def conv (str):
 705         str = re.sub ('([Cc])hord([ea])', '\\1ord\\2', str)
 706         return str
 707
 708 conversions.append (((1,3,144), conv, 'Chorda -> Corda'))
 709
 710
 711
 712 def conv (str):
 713         str = re.sub ('([A-Za-z]+)MinimumVerticalExtent', 'MinimumV@rticalExtent', str)
 714         str = re.sub ('([A-Za-z]+)ExtraVerticalExtent', 'ExtraV@rticalExtent', str)
 715         str = re.sub ('([A-Za-z]+)VerticalExtent', 'VerticalExtent', str)
 716         str = re.sub ('ExtraV@rticalExtent', 'ExtraVerticalExtent', str)
 717         str = re.sub ('MinimumV@rticalExtent', 'MinimumVerticalExtent', str)
 718         return str
 719
 720 conversions.append (((1,3,145), conv,
 721 'ContextNameXxxxVerticalExtent -> XxxxVerticalExtent'))
 722
 723
 724 def conv (str):
 725         str = re.sub ('\\\\key[ \t]*;', '\\key \\default;', str)
 726         str = re.sub ('\\\\mark[ \t]*;', '\\mark \\default;', str)
 727
 728         # Make sure groups of more than one ; have space before
 729         # them, so that non of them gets removed by next rule
 730         str = re.sub ("([^ \n\t;]);(;+)", "\\1 ;\\2", str)
 731
 732         # Only remove ; that are not after spaces, # or ;
 733         # Otherwise  we interfere with Scheme comments,
 734         # which is badbadbad.
 735         str = re.sub ("([^ \t;#]);", "\\1", str)
 736
 737         return str
 738 conversions.append (((1,3,146), conv, 'semicolons removed'))
 739
 740
 741 def conv (str):
 742         str = re.sub ('default-neutral-direction', 'neutral-direction',str)
 743         return str
 744 conversions.append (((1,3,147), conv, 'default-neutral-direction -> neutral-direction'))
 745
 746
 747 def conv (str):
 748         str = re.sub ('\(align', '(axis', str)
 749         str = re.sub ('\(rows', '(columns', str)
 750         return str
 751 conversions.append (((1,3,148), conv, '"(align" -> "(axis", "(rows" -> "(columns"'))
 752
 753
 754
 755 def conv (str):
 756         str = re.sub ('SystemStartDelimiter', 'systemStartDelimiter', str)
 757         return str
 758 conversions.append (((1,5,33), conv, 'SystemStartDelimiter -> systemStartDelimiter'))
 759
 760
 761 def conv (str):
 762         str = re.sub ('arithmetic-multiplier', 'spacing-increment', str)
 763         str = re.sub ('arithmetic-basicspace', 'shortest-duration-space', str)
 764         return str
 765
 766 conversions.append (((1,5,38), conv, 'SystemStartDelimiter -> systemStartDelimiter'))
 767
 768
 769
 770 def conv (str):
 771
 772         def func(match):
 773                 break_dict = {
 774                 "Instrument_name": "instrument-name",
 775                 "Left_edge_item": "left-edge",
 776                 "Span_bar": "span-bar",
 777                 "Breathing_sign": "breathing-sign",
 778                 "Staff_bar": "staff-bar",
 779                 "Clef_item": "clef",
 780                 "Key_item": "key-signature",
 781                 "Time_signature": "time-signature",
 782                 "Custos": "custos"
 783                 }
 784                 props =  match.group (1)
 785                 for (k,v) in break_dict.items():
 786                         props = re.sub (k, v, props)
 787                 return  "breakAlignOrder = #'(%s)" % props
 788
 789         str = re.sub ("breakAlignOrder *= *#'\\(([a-z_\n\tA-Z ]+)\\)",
 790                       func, str)
 791         return str
 792
 793 # 40 ?
 794 conversions.append (((1,5,40), conv, 'breakAlignOrder property names'))
 795
 796
 797
 798 def conv (str):
 799         str = re.sub ('noAutoBeaming *= *##f', 'autoBeaming = ##t', str)
 800         str = re.sub ('noAutoBeaming *= *##t', 'autoBeaming = ##f', str)
 801         return str
 802
 803 conversions.append (((1,5,49), conv, 'noAutoBeaming -> autoBeaming'))
 804
 805
 806 def conv (str):
 807         str = re.sub ('tuplet-bracket-visibility', 'bracket-visibility', str)
 808         str = re.sub ('tuplet-number-visibility', 'number-visibility', str)
 809         return str
 810
 811 conversions.append (((1,5,52), conv, 'tuplet-X-visibility -> X-visibility'))
 812
 813
 814 def conv (str):
 815         str = re.sub ('Pitch::transpose', 'ly-transpose-pitch', str)
 816
 817         return str
 818
 819 conversions.append (((1,5,56), conv, 'Pitch::transpose -> ly-transpose-pitch'))
 820
 821
 822 def conv (str):
 823         str = re.sub ('textNonEmpty *= *##t', "TextScript \\set #'no-spacing-rods = ##f", str)
 824         str = re.sub ('textNonEmpty *= *##f', "TextScript \\set #'no-spacing-rods = ##t", str)
 825         return str
 826
 827 conversions.append (((1,5,58), conv, 'deprecate textNonEmpty'))
 828
 829
 830
 831 def conv (str):
 832         str = re.sub ('MinimumVerticalExtent', 'minimumV@rticalExtent', str)
 833         str = re.sub ('minimumVerticalExtent', 'minimumV@rticalExtent', str)
 834         str = re.sub ('ExtraVerticalExtent', 'extraV@rticalExtent', str)
 835         str = re.sub ('extraVerticalExtent', 'extraV@rticalExtent', str)
 836         str = re.sub ('VerticalExtent', 'verticalExtent', str)
 837         str = re.sub ('extraV@rticalExtent', 'extraVerticalExtent', str)
 838         str = re.sub ('minimumV@rticalExtent', 'minimumVerticalExtent', str)
 839         return str
 840
 841 conversions.append (((1,5,59), conv,
 842 'XxxxVerticalExtent -> xxxVerticalExtent'))
 843
 844
 845 def conv (str):
 846         str = re.sub ('visibility-lambda', 'break-visibility', str)
 847         return str
 848
 849 conversions.append (((1,5,62), conv,
 850 'visibility-lambda -> break-visibility'))
 851
 852
 853
 854 def conv (str):
 855         if re.search (r'\addlyrics',str) \
 856                and re.search ('automaticMelismata', str)  == None:
 857                 error_file.write ('\n')
 858                 error_file.write (NOT_SMART % "automaticMelismata; turned on by default since 1.5.67.")
 859                 error_file.write ('\n')
 860                 raise FatalConversionError ()
 861         return str
 862
 863 conversions.append (((1,5,67), conv,
 864                      'automaticMelismata turned on by default'))
 865
 866
 867 def conv (str):
 868         str = re.sub ('ly-set-grob-property([^!])', 'ly-set-grob-property!\1', str)
 869         str = re.sub ('ly-set-mus-property([^!])', 'ly-set-mus-property!\1', str)
 870         return str
 871
 872 conversions.append (((1,5,68), conv, 'ly-set-X-property -> ly-set-X-property!'))
 873
 874
 875 def conv (str):
 876         str = re.sub ('extent-X', 'X-extent', str)
 877         str = re.sub ('extent-Y', 'Y-extent', str)
 878         return str
 879
 880 conversions.append (((1,5,71), conv, 'extent-[XY] -> [XY]-extent'))
 881
 882
 883
 884 def conv (str):
 885         str = re.sub ("""#\(set! +point-and-click +line-column-location\)""",
 886                       """#(set-point-and-click! \'line-column)""", str)
 887         str = re.sub ("""#\(set![ \t]+point-and-click +line-location\)""",
 888                       '#(set-point-and-click! \'line)', str)
 889         str = re.sub ('#\(set! +point-and-click +#f\)',
 890                       '#(set-point-and-click! \'none)', str)
 891         return str
 892
 893 conversions.append (((1,5,72), conv, 'set! point-and-click -> set-point-and-click!'))
 894
 895
 896
 897 def conv (str):
 898         str = re.sub ('flag-style', 'stroke-style', str)
 899         str = re.sub (r"""Stem([ ]+)\\override #'style""", r"""Stem \\override #'flag-style""", str);
 900         str = re.sub (r"""Stem([ ]+)\\set([ ]+)#'style""", r"""Stem \\set #'flag-style""", str);
 901         return str
 902
 903 conversions.append (((1,6,5), conv, 'Stems: flag-style -> stroke-style; style -> flag-style'))
 904
 905
 906
 907 def subst_req_name (match):
 908         return "(make-music-by-name \'%sEvent)" % regularize_id (match.group(1))
 909
 910 def conv (str):
 911         str = re.sub ('\\(ly-make-music *\"([A-Z][a-z_]+)_req\"\\)', subst_req_name, str)
 912         str = re.sub ('Request_chord', 'EventChord', str)
 913         return str
 914
 915 conversions.append (((1,7,1), conv, 'ly-make-music foo_bar_req -> make-music-by-name FooBarEvent'))
 916
 917
 918
 919 spanner_subst ={
 920         "text" : 'TextSpanEvent',
 921         "decrescendo" : 'DecrescendoEvent',
 922         "crescendo" : 'CrescendoEvent',
 923         "Sustain" : 'SustainPedalEvent',
 924         "slur" : 'SlurEvent',
 925         "UnaCorda" : 'UnaCordaEvent',
 926         "Sostenuto" : 'SostenutoEvent',
 927         }
 928 def subst_ev_name (match):
 929         stype = 'STOP'
 930         if re.search ('start', match.group(1)):
 931                 stype= 'START'
 932
 933         mtype = spanner_subst[match.group(2)]
 934         return "(make-span-event '%s %s)" % (mtype , stype)
 935
 936 def subst_definition_ev_name(match):
 937         return ' = #%s' % subst_ev_name (match)
 938 def subst_inline_ev_name (match):
 939         s = subst_ev_name (match)
 940         return '#(ly-export %s)' % s
 941 def subst_csp_definition (match):
 942         return ' = #(make-event-chord (list %s))' % subst_ev_name (match)
 943 def subst_csp_inline (match):
 944         return '#(ly-export (make-event-chord (list %s)))' % subst_ev_name (match)
 945
 946 def conv (str):
 947         str = re.sub (r' *= *\\spanrequest *([^ ]+) *"([^"]+)"', subst_definition_ev_name, str)
 948         str = re.sub (r'\\spanrequest *([^ ]+) *"([^"]+)"', subst_inline_ev_name, str)
 949         str = re.sub (r' *= *\\commandspanrequest *([^ ]+) *"([^"]+)"', subst_csp_definition, str)
 950         str = re.sub (r'\\commandspanrequest *([^ ]+) *"([^"]+)"', subst_csp_inline, str)
 951         str = re.sub (r'ly-id ', 'ly-import ', str)
 952
 953         str = re.sub (r' *= *\\script "([^"]+)"', ' = #(make-articulation "\\1")', str)
 954         str = re.sub (r'\\script "([^"]+)"', '#(ly-export (make-articulation "\\1"))', str)
 955         return str
 956
 957 conversions.append (((1,7,2), conv, '\\spanrequest -> #(make-span-event .. ), \script -> #(make-articulation .. )'))
 958
 959
 960 def conv(str):
 961         str = re.sub (r'\(ly-', '(ly:', str)
 962
 963         changed = [
 964                 r'duration\?',
 965                 r'font-metric\?',
 966                 r'molecule\?',
 967                 r'moment\?',
 968                 r'music\?',
 969                 r'pitch\?',
 970                 'make-duration',
 971                 'music-duration-length',
 972                 'duration-log',
 973                 'duration-dotcount',
 974                 'intlog2',
 975                 'duration-factor',
 976                 'transpose-key-alist',
 977                 'get-system',
 978                 'get-broken-into',
 979                 'get-original',
 980                 'set-point-and-click!',
 981                 'make-moment',
 982                 'make-pitch',
 983                 'pitch-octave',
 984                 'pitch-alteration',
 985                 'pitch-notename',
 986                 'pitch-semitones',
 987                 r'pitch<\?',
 988                 r'dir\?',
 989                 'music-duration-compress',
 990                 'set-point-and-click!'
 991                 ]
 992
 993         origre = r'\b(%s)' % string.join (changed, '|')
 994
 995         str = re.sub (origre, r'ly:\1',str)
 996         str = re.sub ('set-point-and-click!', 'set-point-and-click', str)
 997
 998         return str
 999
1000 conversions.append (((1,7,3), conv, 'ly- -> ly:'))
1001
1002
1003 def conv(str):
1004         if re.search ('new-chords-done',str):
1005                 return str
1006
1007         str = re.sub (r'<<', '< <', str)
1008         str = re.sub (r'>>', '> >', str)
1009         return str
1010
1011 conversions.append (((1,7,4), conv, '<< >> -> < <  > >'))
1012
1013
1014 def conv(str):
1015         str = re.sub (r"\\transpose", r"\\transpose c'", str)
1016         str = re.sub (r"\\transpose c' *([a-z]+)'", r"\\transpose c \1", str)
1017         return str
1018 conversions.append (((1,7,5), conv, '\\transpose TO -> \\transpose FROM  TO'))
1019
1020
1021 def conv(str):
1022         kws =   ['arpeggio',
1023                  'sustainDown',
1024                  'sustainUp',
1025                  'f',
1026                  'p',
1027                  'pp',
1028                  'ppp',
1029                  'fp',
1030                  'ff',
1031                  'mf',
1032                  'mp',
1033                  'sfz',
1034                  ]
1035
1036         origstr = string.join (kws, '|')
1037         str = re.sub (r'([^_^-])\\(%s)\b' % origstr, r'\1-\\\2', str)
1038         return str
1039 conversions.append (((1,7,6), conv, 'note\\script -> note-\script'))
1040
1041
1042
1043 def conv(str):
1044         str = re.sub (r"\\property *ChordNames *\. *ChordName *\\(set|override) *#'style *= *#('[a-z]+)",
1045                       r"#(set-chord-name-style \2)", str)
1046         str = re.sub (r"\\property *ChordNames *\. *ChordName *\\revert *#'style",
1047                       r"", str)
1048         return str
1049 conversions.append (((1,7,10), conv, "\property ChordName #'style -> #(set-chord-name-style 'style)"))
1050
1051
1052
1053
1054 def conv(str):
1055         str = re.sub (r"ly:transpose-pitch", "ly:pitch-transpose", str)
1056
1057         return str
1058 conversions.append (((1,7,11), conv, "transpose-pitch -> pitch-transpose"))
1059
1060
1061 def conv(str):
1062         str = re.sub (r"ly:get-molecule-extent", "ly:molecule-get-extent", str)
1063         str = re.sub (r"ly:set-molecule-extent!", "ly:molecule-set-extent!", str)
1064         str = re.sub (r"ly:add-molecule", "ly:molecule-add", str)
1065         str = re.sub (r"ly:combine-molecule-at-edge", "ly:molecule-combine-at-edge", str)
1066         str = re.sub (r"ly:align-to!", "ly:molecule-align-to!", str)
1067
1068         return str
1069
1070 conversions.append (((1,7,13), conv, "ly:XX-molecule-YY -> ly:molecule-XX-YY"))
1071
1072
1073 def conv(str):
1074         str = re.sub (r"linewidth *= *-[0-9.]+ *(\\mm|\\cm|\\in|\\pt)?", 'raggedright = ##t', str )
1075         return str
1076
1077 conversions.append (((1,7,15), conv, "linewidth = -1 -> raggedright = ##t"))
1078
1079
1080 def conv(str):
1081         str = re.sub ("divisiomaior",
1082                       "divisioMaior", str)
1083         str = re.sub ("divisiominima",
1084                       "divisioMinima", str)
1085         str = re.sub ("divisiomaxima",
1086                       "divisioMaxima", str)
1087         return str
1088
1089 conversions.append (((1,7,16), conv, "divisiomaior -> divisioMaior"))
1090
1091
1092 def conv(str):
1093         str = re.sub ("Skip_req_swallow_translator",
1094                       "Skip_event_swallow_translator", str)
1095         return str
1096
1097 conversions.append (((1,7,17), conv, "Skip_req  -> Skip_event"))
1098
1099
1100 def conv(str):
1101         str = re.sub ("groupOpen",
1102                       "startGroup", str)
1103         str = re.sub ("groupClose",
1104                       "stopGroup", str)
1105         str = re.sub ("#'outer",
1106                       "#'enclose-bounds", str)
1107
1108         return str
1109
1110 conversions.append (((1,7,18), conv,
1111                      """groupOpen/Close  -> start/stopGroup,
1112                      #'outer  -> #'enclose-bounds
1113                      """))
1114
1115
1116 def conv(str):
1117         if re.search( r'\\GraceContext', str):
1118                 error_file.write ('\n')
1119                 error_file.write (NOT_SMART % "GraceContext")
1120                 error_file.write (FROM_TO \
1121                                   % ("GraceContext", "#(add-to-grace-init .. )"))
1122                 error_file.write ('\n')
1123                 error_file.write (UPDATE_MANUALLY)
1124                 error_file.write ('\n')
1125                 raise FatalConversionError ()
1126
1127         str = re.sub ('HaraKiriStaffContext', 'RemoveEmptyStaffContext', str)
1128         return str
1129
1130 conversions.append (((1,7,19), conv,"remove GraceContext"))
1131
1132
1133
1134
1135 def conv(str):
1136         str = re.sub (
1137                 r"(set|override|revert) *#'type",
1138                 r"\1 #'style",
1139                 str)
1140         return str
1141
1142 conversions.append (((1,7,22), conv,"#'type -> #'style"))
1143
1144
1145 def conv(str):
1146         str = re.sub (
1147                 "barNonAuto *= *##t",
1148                 "automaticBars = ##f",
1149                 str)
1150         str = re.sub (
1151                 "barNonAuto *= *##f",
1152                 "automaticBars = ##t",
1153                 str)
1154         return str
1155
1156 conversions.append (((1,7,23), conv,"barNonAuto -> automaticBars"))
1157
1158
1159
1160 def conv(str):
1161         if re.search( r'-(start|stop)Cluster', str):
1162                 error_file.write ('\n')
1163                 error_file.write (NOT_SMART % "Cluster syntax")
1164                 error_file.write ('\n')
1165                 error_file.write (UPDATE_MANUALLY)
1166                 error_file.write ('\n')
1167
1168                 raise FatalConversionError ()
1169
1170         return str
1171
1172 conversions.append (((1,7,24), conv,"cluster syntax"))
1173
1174
1175 def conv(str):
1176         str = re.sub (r"\\property *Staff\.(Sustain|Sostenuto|UnaCorda)Pedal *\\(override|set) *#'pedal-type *",
1177                         r"\property Staff.pedal\1Style ", str)
1178         str = re.sub (r"\\property *Staff\.(Sustain|Sostenuto|UnaCorda)Pedal *\\revert *#'pedal-type", '', str)
1179         return str
1180
1181 conversions.append (((1,7,28), conv,"new Pedal style syntax"))
1182
1183
1184
1185
1186
1187 def sub_chord (m):
1188         str = m.group(1)
1189
1190         origstr =  '<%s>' % str
1191         if re.search (r'\\\\', str):
1192                 return origstr
1193
1194         if re.search (r'\\property', str):
1195                 return origstr
1196
1197         if re.match (r'^\s*\)?\s*\\[a-zA-Z]+', str):
1198                 return origstr
1199
1200         durs = []
1201         def sub_durs (m, durs = durs):
1202                 durs.append(m.group(2))
1203                 return m.group (1)
1204
1205         str = re.sub (r"([a-z]+[,'!? ]*)([0-9]+\.*)", sub_durs, str)
1206         dur_str = ''
1207
1208         for d in durs:
1209                 if dur_str == '':
1210                         dur_str = d
1211                 if dur_str <> d:
1212                         return '<%s>' % m.group (1)
1213
1214         pslur_strs = ['']
1215         dyns = ['']
1216         slur_strs = ['']
1217
1218         last_str = ''
1219         while last_str <> str:
1220                 last_str = str
1221
1222                 def sub_tremolos (m, slur_strs = slur_strs):
1223                         tr = m.group (2)
1224                         if tr not in slur_strs:
1225                                 slur_strs.append (tr)
1226                         return  m.group (1)
1227
1228                 str = re.sub (r"([a-z]+[',!? ]*)(:[0-9]+)",
1229                               sub_tremolos, str)
1230
1231                 def sub_dyn_end (m, dyns = dyns):
1232                         dyns.append (' \!')
1233                         return ' ' + m.group(2)
1234
1235                 str = re.sub (r'(\\!)\s*([a-z]+)', sub_dyn_end, str)
1236                 def sub_slurs(m, slur_strs = slur_strs):
1237                         if '-)' not in slur_strs:
1238                                 slur_strs.append (')')
1239                         return m.group(1)
1240
1241                 def sub_p_slurs(m, slur_strs = slur_strs):
1242                         if '-\)' not in slur_strs:
1243                                 slur_strs.append ('\)')
1244                         return m.group(1)
1245
1246                 str = re.sub (r"\)[ ]*([a-z]+)", sub_slurs, str)
1247                 str = re.sub (r"\\\)[ ]*([a-z]+)", sub_p_slurs, str)
1248                 def sub_begin_slurs(m, slur_strs = slur_strs):
1249                         if '-(' not in slur_strs:
1250                                 slur_strs.append ('(')
1251                         return m.group(1)
1252
1253                 str = re.sub (r"([a-z]+[,'!?0-9 ]*)\(",
1254                               sub_begin_slurs, str)
1255                 def sub_begin_p_slurs(m, slur_strs = slur_strs):
1256                         if '-\(' not in slur_strs:
1257                                 slur_strs.append ('\(')
1258                         return m.group(1)
1259
1260                 str = re.sub (r"([a-z]+[,'!?0-9 ]*)\\\(",
1261                         sub_begin_p_slurs, str)
1262
1263                 def sub_dyns (m, slur_strs = slur_strs):
1264                         s = m.group(0)
1265                         if s == '@STARTCRESC@':
1266                                 slur_strs.append ("\\<")
1267                         elif s == '@STARTDECRESC@':
1268                                 slur_strs.append ("\\>")
1269                         elif s == r'-?\\!':
1270                                 slur_strs.append ('\\!')
1271                         return ''
1272
1273                 str = re.sub (r'@STARTCRESC@', sub_dyns, str)
1274                 str = re.sub (r'-?\\!', sub_dyns, str)
1275
1276                 def sub_articulations (m, slur_strs = slur_strs):
1277                         a = m.group(1)
1278                         if a not in slur_strs:
1279                                 slur_strs.append (a)
1280                         return ''
1281
1282                 str = re.sub (r"([_^-]\@ACCENT\@)", sub_articulations,
1283                               str)
1284                 str = re.sub (r"([_^-]\\[a-z]+)", sub_articulations,
1285                               str)
1286                 str = re.sub (r"([_^-][>_.+|^-])", sub_articulations,
1287                               str)
1288                 str = re.sub (r'([_^-]"[^"]+")', sub_articulations,
1289                               str)
1290
1291                 def sub_pslurs(m, slur_strs = slur_strs):
1292                         slur_strs.append (' \\)')
1293                         return m.group(1)
1294                 str = re.sub (r"\\\)[ ]*([a-z]+)", sub_pslurs, str)
1295
1296         ## end of while <>
1297
1298         suffix = string.join (slur_strs, '') + string.join (pslur_strs,
1299                                                             '') \
1300                  + string.join (dyns, '')
1301
1302         return '@STARTCHORD@%s@ENDCHORD@%s%s' % (str , dur_str, suffix)
1303
1304
1305
1306 def sub_chords (str):
1307         simend = '>'
1308         simstart = '<'
1309         chordstart = '<<'
1310         chordend = '>>'
1311         marker_str = '%% new-chords-done %%'
1312
1313         if re.search (marker_str,str):
1314                 return str
1315         str = re.sub ('<<', '@STARTCHORD@', str)
1316         str = re.sub ('>>', '@ENDCHORD@', str)
1317
1318         str = re.sub (r'\\<', '@STARTCRESC@', str)
1319         str = re.sub (r'\\>', '@STARTDECRESC@', str)
1320         str = re.sub (r'([_^-])>', r'\1@ACCENT@', str)
1321         str = re.sub (r'<([^<>{}]+)>', sub_chord, str)
1322
1323         # add dash: -[, so that [<<a b>> c d] becomes
1324         #                      <<a b>>-[ c d]
1325         # and gets skipped by articulation_substitute
1326         str = re.sub (r'\[ *(@STARTCHORD@[^@]+@ENDCHORD@[0-9.]*)',
1327                       r'\1-[', str)
1328         str = re.sub (r'\\! *(@STARTCHORD@[^@]+@ENDCHORD@[0-9.]*)',
1329                       r'\1-\\!', str)
1330
1331         str = re.sub (r'<([^?])', r'%s\1' % simstart, str)
1332         str = re.sub (r'>([^?])', r'%s\1' % simend,  str)
1333         str = re.sub ('@STARTCRESC@', r'\\<', str)
1334         str = re.sub ('@STARTDECRESC@', r'\\>' ,str)
1335         str = re.sub (r'\\context *Voice *@STARTCHORD@',
1336                       '@STARTCHORD@', str)
1337         str = re.sub ('@STARTCHORD@', chordstart, str)
1338         str = re.sub ('@ENDCHORD@', chordend, str)
1339         str = re.sub (r'@ACCENT@', '>', str)
1340         return str
1341
1342 markup_start = re.compile(r"([-^_]|\\mark)\s*(#\s*'\s*)\(")
1343 musicglyph = re.compile(r"\(\s*music\b")
1344 columns = re.compile(r"\(\s*columns\b")
1345 submarkup_start = re.compile(r"\(\s*([a-zA-Z]+)")
1346 leftpar = re.compile(r"\(")
1347 rightpar = re.compile(r"\)")
1348
1349 def text_markup (str):
1350         result = ''
1351         # Find the beginning of each markup:
1352         match = markup_start.search (str)
1353         while match:
1354                 result = result + str[:match.end (1)] + " \markup"
1355                 str = str[match.end( 2):]
1356                 # Count matching parentheses to find the end of the
1357                 # current markup:
1358                 nesting_level = 0
1359                 pars = re.finditer(r"[()]",str)
1360                 for par in pars:
1361                         if par.group () == '(':
1362                                 nesting_level = nesting_level + 1
1363                         else:
1364                                 nesting_level = nesting_level - 1
1365                         if nesting_level == 0:
1366                                 markup_end = par.end ()
1367                                 break
1368                 # The full markup in old syntax:
1369                 markup = str[:markup_end]
1370                 # Modify to new syntax:
1371                 markup = musicglyph.sub (r"{\\musicglyph", markup)
1372                 markup = columns.sub (r"{", markup)
1373                 markup = submarkup_start.sub (r"{\\\1", markup)
1374                 markup = leftpar.sub ("{", markup)
1375                 markup = rightpar.sub ("}", markup)
1376
1377                 result = result + markup
1378                 # Find next markup
1379                 str = str[markup_end:]
1380                 match = markup_start.search(str)
1381         result = result + str
1382         return result
1383
1384 def articulation_substitute (str):
1385         str = re.sub (r"""([^-])\[ *(\\?\)?[a-z]+[,']*[!?]?[0-9:]*\.*)""",
1386                       r"\1 \2[", str)
1387         str = re.sub (r"""([^-])\\\) *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
1388                       r"\1 \2\\)", str)
1389         str = re.sub (r"""([^-\\])\) *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
1390                       r"\1 \2)", str)
1391         str = re.sub (r"""([^-])\\! *([a-z]+[,']*[!?]?[0-9:]*\.*)""",
1392                       r"\1 \2\\!", str)
1393         return str
1394
1395 string_or_scheme = re.compile ('("(?:[^"\\\\]|\\\\.)*")|(#\\s*\'?\\s*\\()')
1396
1397 # Only apply articulation_substitute () outside strings and
1398 # Scheme expressions:
1399 def smarter_articulation_subst (str):
1400         result = ''
1401         # Find the beginning of next string or Scheme expr.:
1402         match = string_or_scheme.search (str)
1403         while match:
1404                 # Convert the preceding LilyPond code:
1405                 previous_chunk = str[:match.start()]
1406                 result = result + articulation_substitute (previous_chunk)
1407                 if match.group (1): # Found a string
1408                         # Copy the string to output:
1409                         result = result + match.group (1)
1410                         str = str[match.end(1):]
1411                 else: # Found a Scheme expression. Count
1412                         # matching parentheses to find its end
1413                         str = str[match.start ():]
1414                         nesting_level = 0
1415                         pars = re.finditer(r"[()]",str)
1416                         for par in pars:
1417                                 if par.group () == '(':
1418                                         nesting_level = nesting_level + 1
1419                                 else:
1420                                         nesting_level = nesting_level - 1
1421                                 if nesting_level == 0:
1422                                         scheme_end = par.end ()
1423                                         break
1424                         # Copy the Scheme expression to output:
1425                         result = result + str[:scheme_end]
1426                         str = str[scheme_end:]
1427                 # Find next string or Scheme expression:
1428                 match = string_or_scheme.search (str)
1429         # Convert the remainder of the file
1430         result = result + articulation_substitute (str)
1431         return result
1432
1433 def conv_relative(str):
1434         if re.search (r"\\relative", str):
1435                 str= "#(ly:set-option 'old-relative)\n" + str
1436
1437         return str
1438
1439 def conv (str):
1440         str = re.sub (r"#'\(\)", "@SCM_EOL@", str)
1441         str =  conv_relative (str)
1442         str = sub_chords (str)
1443
1444         str = text_markup (str)
1445         str = smarter_articulation_subst (str)
1446         str = re.sub ("@SCM_EOL@", "#'()", str)
1447
1448         return str
1449
1450 conversions.append (((1,9,0), conv, """New relative mode,
1451 Postfix articulations, new text markup syntax, new chord syntax."""))
1452
1453
1454 def conv (str):
1455         if re.search ("font-style",str):
1456                 error_file.write ('\n')
1457                 error_file.write (NOT_SMART % "font-style")
1458                 error_file.write ('\n')
1459                 error_file.write (UPDATE_MANUALLY)
1460                 error_file.write ('\n')
1461
1462                 raise FatalConversionError ()
1463
1464         str = re.sub (r'-\\markup', r'@\\markup', str)
1465         str = re.sub (r'-\\', r'\\', str)
1466         str = re.sub (r'-\)', ')', str)
1467         str = re.sub (r'-\(', '(', str)
1468         str = re.sub ('-\[', '[', str)
1469         str = re.sub ('-\]', ']', str)
1470         str = re.sub ('-~', '~', str)
1471         str = re.sub (r'@\\markup', r'-\\markup', str)
1472         return str
1473
1474 conversions.append (((1,9,1), conv, """Remove - before articulation"""))
1475
1476 def conv (str):
1477         str = re.sub ('ly:set-context-property',
1478                       'ly:set-context-property!', str)
1479         str = re.sub ('\\\\newcontext', '\\\\new', str)
1480         str = re.sub ('\\\\grace[\t\n ]*([^{ ]+)',
1481                       r'\\grace { \1 }', str)
1482         str = re.sub ("\\\\grace[\t\n ]*{([^}]+)}",
1483                       r"""\\grace {
1484 \\property Voice.Stem \\override #'stroke-style = #"grace"
1485   \1
1486   \\property Voice.Stem \\revert #'stroke-style }
1487 """, str)
1488
1489         return str
1490
1491 conversions.append (((1,9,2), conv, """\\newcontext -> \\new"""))
1492
1493 def conv (str):
1494         str = re.sub ('accacciatura',
1495                       'acciaccatura', str)
1496
1497         if re.search ("context-spec-music", str):
1498                 error_file.write ('\n')
1499                 error_file.write (NOT_SMART % "context-spec-music")
1500                 error_file.write ('\n')
1501                 error_file.write (UPDATE_MANUALLY)
1502                 error_file.write ('\n')
1503
1504                 raise FatalConversionError ()
1505
1506         str = re.sub ('fingerHorizontalDirection *= *#(LEFT|-1)',
1507                       "fingeringOrientations = #'(up down left)", str)
1508         str = re.sub ('fingerHorizontalDirection *= *#(RIGHT|1)',
1509                       "fingeringOrientations = #'(up down right)", str)
1510
1511         return str
1512
1513 conversions.append (((1,9,3), conv,
1514                      """\\acciaccatura misspelling, fingerHorizontalDirection -> fingeringOrientations"""))
1515
1516
1517 def conv (str):
1518         if re.search ('\\figures', str):
1519                 error_file.write ("Warning: attempting automatic \\figures conversion.  Check results!");
1520
1521
1522         def figures_replace (m):
1523                 s = m.group (1)
1524                 s = re.sub ('<', '@FIGOPEN@',s)
1525                 s = re.sub ('>', '@FIGCLOSE@',s)
1526                 return '\\figures { %s }' % s
1527
1528         str = re.sub (r'\\figures[ \t\n]*{([^}]+)}', figures_replace, str)
1529         str = re.sub (r'\\<', '@STARTCRESC@', str)
1530         str = re.sub (r'\\>', '@STARTDECRESC@', str)
1531         str = re.sub (r'([-^_])>', r'\1@ACCENT@', str)
1532         str = re.sub (r'<<', '@STARTCHORD@', str)
1533         str = re.sub (r'>>', '@ENDCHORD@', str)
1534         str = re.sub (r'>', '@ENDSIMUL@', str)
1535         str = re.sub (r'<', '@STARTSIMUL@', str)
1536         str = re.sub ('@STARTDECRESC@', '\\>', str)
1537         str = re.sub ('@STARTCRESC@', '\\<', str)
1538         str = re.sub ('@ACCENT@', '>', str)
1539         str = re.sub ('@ENDCHORD@', '>', str)
1540         str = re.sub ('@STARTCHORD@', '<', str)
1541         str = re.sub ('@STARTSIMUL@', '<<', str)
1542         str = re.sub ('@ENDSIMUL@', '>>', str)
1543         str = re.sub ('@FIGOPEN@', '<', str)
1544         str = re.sub ('@FIGCLOSE@', '>', str)
1545
1546         return str
1547
1548 conversions.append (((1,9,4), conv, 'Swap < > and << >>'))
1549
1550
1551 def conv (str):
1552         str = re.sub ('HaraKiriVerticalGroup', 'RemoveEmptyVerticalGroup', str)
1553
1554         return str
1555
1556 conversions.append (((1,9,5), conv, 'HaraKiriVerticalGroup -> RemoveEmptyVerticalGroup'))
1557
1558 def conv (str):
1559         if re.search ("ly:get-font", str) :
1560                 error_file.write ('\n')
1561                 error_file.write (NOT_SMART % "(ly:-get-font")
1562                 error_file.write ('\n')
1563                 error_file.write (FROM_TO \
1564                                   % ("(ly:paper-get-font (ly:grob-get-paper foo) .. )",
1565                                      "(ly:paper-get-font (ly:grob-get-paper foo) .. )"))
1566                 error_file.write (UPDATE_MANUALLY)
1567                 error_file.write ('\n')
1568                 raise FatalConversionError ()
1569
1570         if re.search ("\\pitch *#", str) :
1571                 error_file.write ('\n')
1572                 error_file.write (NOT_SMART % "\\pitch")
1573                 error_file.write ('\n')
1574                 error_file.write ("Use Scheme code to construct arbitrary note events.")
1575                 error_file.write ('\n')
1576
1577                 raise FatalConversionError ()
1578
1579         return str
1580
1581
1582 conversions.append (((1,9,6), conv, 'ly:get-font deprecated.'))
1583
1584 def conv (str):
1585         def sub_alteration (m):
1586                 alt = m.group (3)
1587                 alt = {
1588                         '-1': 'FLAT',
1589                         '-2': 'DOUBLE-FLAT',
1590                         '0': 'NATURAL',
1591                         '1': 'SHARP',
1592                         '2': 'DOUBLE-SHARP',
1593                         }[alt]
1594
1595                 return '(ly:make-pitch %s %s %s)' % (m.group(1), m.group (2),
1596                                                      alt)
1597
1598         str =re.sub ("\\(ly:make-pitch *([0-9-]+) *([0-9-]+) *([0-9-]+) *\\)",
1599                      sub_alteration, str)
1600
1601
1602         str = re.sub ("ly:verbose", "ly:get-option 'verbose", str)
1603
1604         m= re.search ("\\\\outputproperty #([^#]+)[\t\n ]*#'([^ ]+)", str)
1605         if m:
1606                 error_file.write (\
1607                         r"""\outputproperty found,
1608 Please hand-edit, using
1609
1610   \applyoutput #(outputproperty-compatibility %s '%s <GROB PROPERTY VALUE>)
1611
1612 as a substitution text.""" % (m.group (1), m.group (2)) )
1613                 raise FatalConversionError ()
1614
1615         if re.search ("ly:(make-pitch|pitch-alteration)", str) \
1616                or re.search ("keySignature", str):
1617                 error_file.write ('\n')
1618                 error_file.write (NOT_SMART % "pitches")
1619                 error_file.write ('\n')
1620                 error_file.write (
1621 """The alteration field of Scheme pitches was multiplied by 2
1622 to support quarter tone accidentals.  You must update the following constructs by manually:
1623
1624 * calls of ly:make-pitch and ly:pitch-alteration
1625 * keySignature settings made with \property
1626 """)
1627                 raise FatalConversionError ()
1628
1629         return str
1630 conversions.append (((1,9,7), conv,
1631                      '''use symbolic constants for alterations,
1632 remove \\outputproperty, move ly:verbose into ly:get-option'''))
1633
1634
1635 def conv (str):
1636         if re.search ("dash-length",str):
1637                 error_file.write ('\n')
1638                 error_file.write (NOT_SMART % "dash-length")
1639                 error_file.write ('\n')
1640                 error_file.write (FROM_TO % ("dash-length", "dash-fraction"))
1641                 error_file.write ('\n')
1642                 error_file.write (UPDATE_MANUALLY)
1643                 error_file.write ('\n')
1644                 raise FatalConversionError ()
1645         return str
1646
1647 conversions.append (((1,9,8), conv, """dash-length -> dash-fraction"""))
1648
1649
1650 def conv (str):
1651         def func(match):
1652                 return "#'font-size = #%d" % (2*string.atoi (match.group (1)))
1653
1654         str =re.sub (r"#'font-relative-size\s*=\s*#\+?([0-9-]+)", func, str)
1655         str =re.sub (r"#'font-family\s*=\s*#'ancient",
1656                      r"#'font-family = #'music", str)
1657
1658         return str
1659
1660 conversions.append (((2,1,1), conv, """font-relative-size -> font-size"""))
1661
1662 def conv (str):
1663         str =re.sub (r"ly:get-music-length", "ly:music-length", str)
1664         return str
1665
1666 conversions.append (((2,1,2), conv, """ly:get-music-length -> ly:music-length"""))
1667
1668 def conv (str):
1669         str =re.sub (r"\.\s+stz=", ". instr ", str)
1670         return str
1671
1672 conversions.append (((2,1,3), conv, """stanza -> instrument"""))
1673
1674 def conv (str):
1675         def func (match):
1676                 c = match.group (1)
1677                 b = match.group (2)
1678
1679                 if b == 't':
1680                         if c == 'Score':
1681                                 return ''
1682                         else:
1683                                 return r" \property %s.melismaBusyProperties \unset"  % c
1684                 elif b == 'f':
1685                         return r"\property %s.melismaBusyProperties = #'(melismaBusy)"  % c
1686
1687         str = re.sub (r"\\property ([a-zA-Z]+)\s*\.\s*automaticMelismata\s*=\s*##([ft])", func, str)
1688         return str
1689
1690 conversions.append (((2,1,4), conv, """removal of automaticMelismata; use melismaBusyProperties instead."""))
1691
1692
1693
1694 def conv (str):
1695         str =re.sub (r"\\translator\s+([a-zA-Z]+)", r"\\change \1", str)
1696         return str
1697
1698 conversions.append (((2,1,7), conv, """\\translator Staff -> \\change Staff"""))
1699
1700 def conv (str):
1701         str =re.sub (r"\\newaddlyrics", r"\\lyricsto", str)
1702         return str
1703
1704 conversions.append (((2,1,10), conv, """\\newaddlyrics -> \\lyricsto"""))
1705
1706 def conv (str):
1707         str = re.sub (r'\\include\s*"paper([0-9]+)(-init)?.ly"',
1708                       r"#(set-staff-size \1)", str)
1709
1710         def sub_note (match):
1711                 dur = ''
1712                 log = string.atoi (match.group (1))
1713                 dots = string.atoi (match.group (2))
1714
1715                 if log >= 0:
1716                         dur = '%d' % (1 << log)
1717                 else:
1718                         dur = { -1 : 'breve',
1719                                 -2 : 'longa',
1720                                 -3 : 'maxima'}[log]
1721
1722                 dur += ('.' * dots)
1723
1724                 return r'\note #"%s" #%s' % (dur, match.group (3))
1725
1726         str = re.sub (r'\\note\s+#([0-9-]+)\s+#([0-9]+)\s+#([0-9.-]+)',
1727                       sub_note, str)
1728         return str
1729
1730 conversions.append (((2,1,11), conv, """\\include "paper16.ly" -> #(set-staff-size 16)
1731 \\note #3 #1 #1 -> \\note #"8." #1
1732 """))
1733
1734
1735 def conv (str):
1736         str =re.sub (r"OttavaSpanner", r"OttavaBracket", str)
1737         return str
1738
1739 conversions.append (((2,1,12), conv, """OttavaSpanner -> OttavaBracket"""))
1740
1741
1742 def conv (str):
1743         str =re.sub (r"\(set-staff-size ", r"(set-global-staff-size ", str)
1744         return str
1745
1746 conversions.append (((2,1,13), conv, """set-staff-size -> set-global-staff-size"""))
1747
1748 def conv (str):
1749         str =re.sub (r"#'style\s*=\s*#'dotted-line",
1750                      r"#'dash-fraction = #0.0 ", str)
1751         return str
1752
1753 conversions.append (((2,1,14), conv, """style = dotted -> dash-fraction = 0"""))
1754
1755 def conv (str):
1756         str =re.sub (r'LyricsVoice\s*\.\s*instrument\s*=\s*("[^"]*")',
1757                      r'LyricsVoice . vocalName = \1', str)
1758
1759         str =re.sub (r'LyricsVoice\s*\.\s*instr\s*=\s*("[^"]*")',
1760                      r'LyricsVoice . vocNam = \1', str)
1761         return str
1762
1763 conversions.append (((2,1,15), conv, """LyricsVoice . instr(ument) -> vocalName"""))
1764
1765 def conv (str):
1766         def sub_acc (m):
1767                 d = {
1768                 '4': 'doublesharp',
1769                 '3': 'threeqsharp',
1770                 '2': 'sharp',
1771                 '1': 'semisharp',
1772                 '0': 'natural',
1773                 '-1': 'semiflat',
1774                 '-2': 'flat',
1775                 '-3': 'threeqflat',
1776                 '-4': 'doubleflat'}
1777                 return '\\%s' %  d[m.group (1)]
1778
1779         str = re.sub (r'\\musicglyph\s*#"accidentals-([0-9-]+)"',
1780                       sub_acc, str)
1781         return str
1782
1783 conversions.append (((2,1,16), conv, """\\musicglyph #"accidentals-NUM" -> \\sharp/flat/etc."""))
1784
1785
1786 def conv (str):
1787
1788         if re.search (r'\\partcombine', str):
1789                 error_file.write ('\n')
1790                 error_file.write (NOT_SMART % "\\partcombine")
1791                 error_file.write ('\n')
1792                 error_file.write (UPDATE_MANUALLY)
1793                 error_file.write ('\n')
1794                 raise FatalConversionError ()
1795
1796         # this rule doesn't really work,
1797         # too lazy to figure out why.
1798         str = re.sub (r'\\context\s+Voice\s*=\s*one\s*\\partcombine\s+Voice\s*\\context\s+Thread\s*=\s*one(.*)\s*'
1799                       + r'\\context\s+Thread\s*=\s*two',
1800                       '\\\\newpartcombine\n\\1\n', str)
1801
1802
1803         return str
1804
1805 conversions.append (((2,1,17), conv, """\\partcombine syntax change to \\newpartcombine"""))
1806
1807
1808 def conv (str):
1809         str = re.sub (r'\\newpartcombine', r'\\partcombine', str)
1810         str = re.sub (r'\\autochange\s+Staff', r'\\autochange ', str)
1811         return str
1812
1813 conversions.append (((2,1,18), conv, """\\newpartcombine -> \\partcombine,
1814 \\autochange Staff -> \\autochange
1815 """))
1816
1817
1818
1819
1820 def conv (str):
1821         str = re.sub (r'\\include "drumpitch-init.ly"','', str)
1822         str = re.sub (r'\\pitchnames ','pitchnames = ', str)
1823         str = re.sub (r'\\chordmodifiers ','chordmodifiers = ', str)
1824         str = re.sub (r'\bdrums\b\s*=','drumContents = ', str)
1825         str = re.sub (r'\\drums\b','\\drumContents ', str)
1826
1827
1828         if re.search ('drums->paper', str):
1829                 error_file.write ("\nDrum notation found. Check file manually!")
1830
1831         str = re.sub (r"""\\apply\s+#\(drums->paper\s+'([a-z]+)\)""",
1832                       r"""\property DrumStaff.drumStyleTable = #\1-style""",
1833                       str)
1834
1835         if re.search ('Thread', str):
1836                 error_file.write ("\nThread found. Check file manually!\n");
1837
1838         str = re.sub (r"""(\\once\s*)?\\property\s+Thread\s*\.\s*NoteHead\s*"""
1839                       + r"""\\(set|override)\s*#'style\s*=\s*#'harmonic"""
1840                       + r"""\s+([a-z]+[,'=]*)([0-9]*\.*)"""
1841                       ,r"""<\3\\harmonic>\4""", str)
1842
1843         str = re.sub (r"""\\new Thread""", """\context Voice""", str)
1844         str = re.sub (r"""Thread""", """Voice""", str)
1845
1846         if re.search ('\bLyrics\b', str):
1847                 error_file.write ("\nLyrics found. Check file manually!\n");
1848
1849         str = re.sub (r"""LyricsVoice""", r"""L@ricsVoice""", str)
1850         str = re.sub (r"""\bLyrics\b""", r"""LyricsVoice""", str)
1851         str = re.sub (r"""LyricsContext""", r"""LyricsVoiceContext""", str)
1852         str = re.sub (r"""L@ricsVoice""", r"""LyricsVoice""",str)
1853
1854
1855         return str
1856
1857 conversions.append (((2,1,19), conv, """Drum notation changes, Removing \\chordmodifiers, \\notenames.
1858 Harmonic notes. Thread context removed. Lyrics context removed."""))
1859
1860 def conv (str):
1861         str = re.sub (r'nonevent-skip', 'skip-music', str)
1862         return str
1863
1864 conversions.append (((2,1,20), conv, """nonevent-skip -> skip-music""" ))
1865
1866 def conv (str):
1867         str = re.sub (r'molecule-callback', 'print-function', str)
1868         str = re.sub (r'brew_molecule', 'print', str)
1869         str = re.sub (r'brew-new-markup-molecule', 'Text_item::print', str)
1870         str = re.sub (r'LyricsVoice', 'Lyrics', str)
1871         str = re.sub (r'tupletInvisible',
1872                       r"TupletBracket \\set #'transparent", str)
1873 #       str = re.sub (r'molecule', 'collage', str)
1874 #molecule -> collage
1875         str = re.sub (r"\\property\s+[a-zA-Z]+\s*\.\s*[a-zA-Z]+\s*"
1876                       + r"\\set\s*#'X-extent-callback\s*=\s*#Grob::preset_extent",
1877                       "", str)
1878
1879         return str
1880
1881 conversions.append (((2,1,21), conv, """molecule-callback -> print-function,
1882 brew_molecule -> print
1883 brew-new-markup-molecule -> Text_item::print
1884 LyricsVoice -> Lyrics
1885 tupletInvisible -> TupletBracket \set #'transparent
1886 Grob::preset_extent removed.
1887 """ ))
1888
1889
1890 def conv (str):
1891         str = re.sub (r'(\\property[^=]+)=\s*([-0-9]+)',
1892                       r'\1= #\2', str)
1893         str = re.sub (r'\\property\s+([^. ]+)\s*\.\s*([^\\=]+)\s*\\(set|override)',
1894                       r"\\overrid@ \1.\2 ", str)
1895         str = re.sub (r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*=\s*',
1896                       r'\\s@t \1.\2 = ', str)
1897         str = re.sub (r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*\\unset',
1898                       r'\\uns@t \1.\2 ', str)
1899         str = re.sub (r'\\property\s+([^. ]+)\s*\.\s*([^\\= ]+)\s*\\revert'
1900                       + r"\s*#'([-a-z0-9_]+)",
1901                       r"\\rev@rt \1.\2 #'\3", str)
1902         str = re.sub (r'Voice\.', '', str)
1903         str = re.sub (r'Lyrics\.', '', str)
1904         str = re.sub (r'ChordNames\.', '', str)
1905
1906         str = re.sub ('rev@rt', 'revert',str)
1907         str = re.sub ('s@t', 'set',str)
1908         str = re.sub ('overrid@', 'override',str)
1909
1910         str = re.sub ('molecule', 'stencil', str)
1911         str = re.sub ('Molecule', 'Stencil', str)
1912         return str
1913
1914 conversions.append (((2,1,22), conv, """new syntax for property settings:
1915         \\set A.B = #C , \\unset A.B
1916         \\override A.B #C = #D, \\revert A.B #C
1917
1918 """))
1919
1920 def conv (str):
1921         def subst_in_trans (match):
1922                 s = match.group (0)
1923                 s = re.sub (r'\s([a-zA-Z]+)\s*\\override',
1924                               r' \\override \1', s)
1925                 s = re.sub (r'\s([a-zA-Z]+)\s*\\set',
1926                               r' \\override \1', s)
1927                 s = re.sub (r'\s([a-zA-Z]+)\s*\\revert',
1928                               r' \\revert \1', s)
1929                 return s
1930         str = re.sub (r'\\(translator|with)\s*{[^}]+}',  subst_in_trans, str)
1931
1932         def sub_abs (m):
1933
1934                 context = m.group ('context')
1935                 d = m.groupdict ()
1936                 if context:
1937                         context = " '%s" % context[:-1] # -1: remove .
1938                 else:
1939                         context = ''
1940
1941                 d['context'] = context
1942
1943                 return r"""#(override-auto-beam-setting %(prop)s %(num)s %(den)s%(context)s)""" % d
1944
1945         str = re.sub (r"""\\override\s*(?P<context>[a-zA-Z]+\s*\.\s*)?autoBeamSettings"""
1946                       +r"""\s*#(?P<prop>[^=]+)\s*=\s*#\(ly:make-moment\s+(?P<num>\d+)\s+(?P<den>\d)\s*\)""",
1947                       sub_abs, str)
1948
1949         return str
1950
1951 conversions.append (((2,1,23), conv, """Property setting syntax in \\translator{ }"""))
1952 def conv (str):
1953         str = re.sub (r'music-list\?', 'ly:music-list?', str)
1954         str = re.sub (r'\|\s*~', '~ |', str)
1955         return str
1956
1957 conversions.append (((2,1,24), conv, """music-list? -> ly:music-list?"""))
1958
1959 def conv (str):
1960         str = re.sub (r'ly:get-spanner-bound', 'ly:spanner-get-bound', str)
1961         str = re.sub (r'ly:get-extent', 'ly:grob-extent', str)
1962         str = re.sub (r'ly:get-system', 'ly:grob-system', str)
1963         str = re.sub (r'ly:get-original', 'ly:grob-original', str)
1964         str = re.sub (r'ly:get-parent', 'ly:grob-parent', str)
1965         str = re.sub (r'ly:get-broken-into', 'ly:spanner-broken-into', str)
1966         str = re.sub (r'Melisma_engraver', 'Melisma_translator', str)
1967         if re.search ("ly:get-paper-variable", str):
1968                 error_file.write ('\n')
1969                 error_file.write (NOT_SMART % "ly:paper-get-variable")
1970                 error_file.write ('\n')
1971                 error_file.write ('use (ly:paper-lookup (ly:grob-paper ))')
1972                 error_file.write ('\n')
1973                 raise FatalConversionError ()
1974
1975         str = re.sub (r'\\defaultAccidentals', "#(set-accidental-style 'default)", str)
1976         str = re.sub (r'\\voiceAccidentals', "#(set-accidental-style 'voice)", str)
1977         str = re.sub (r'\\modernAccidentals', "#(set-accidental-style 'modern)", str)
1978         str = re.sub (r'\\modernCautionaries', "#(set-accidental-style 'modern-cautionary)", str)
1979         str = re.sub (r'\\modernVoiceAccidental', "#(set-accidental-style 'modern-voice)", str)
1980         str = re.sub (r'\\modernVoiceCautionaries', "#(set-accidental-style 'modern-voice-cautionary)", str)
1981         str = re.sub (r'\\pianoAccidentals', "#(set-accidental-style 'piano)", str)
1982         str = re.sub (r'\\pianoCautionaries', "#(set-accidental-style 'piano-cautionary)", str)
1983         str = re.sub (r'\\forgetAccidentals', "#(set-accidental-style 'forget)", str)
1984         str = re.sub (r'\\noResetKey', "#(set-accidental-style 'no-reset)", str)
1985
1986         return str
1987
1988 conversions.append (((2,1,25), conv, """Scheme grob function renaming"""))
1989
1990
1991 def conv (str):
1992         str = re.sub ('ly:set-grob-property!', 'ly:grob-set-property!',str)
1993         str = re.sub ('ly:set-mus-property!', 'ly:music-set-property!',str)
1994         str = re.sub ('ly:set-context-property!', 'ly:context-set-property!', str)
1995         str = re.sub ('ly:get-grob-property', 'ly:grob-property',str)
1996         str = re.sub ('ly:get-mus-property', 'ly:music-property',str)
1997         str = re.sub ('ly:get-context-property', 'ly:context-property',str)
1998
1999         return str
2000
2001 conversions.append (((2,1,26), conv, """More Scheme function renaming"""))
2002
2003 def conv (str):
2004         def subst (m):
2005                 g = string.atoi (m.group (2))
2006                 o = g / 12
2007                 g -= o * 12
2008                 if g <  0:
2009                         g += 12
2010                         o -= 1
2011
2012
2013                 lower_pitches = filter (lambda x : x <= g, [0, 2, 4, 5, 7, 9, 11, 12])
2014                 s = len (lower_pitches) -1
2015                 a = g - lower_pitches [-1]
2016
2017
2018                 print s , lower_pitches, g, a, s
2019                 str = 'cdefgab' [s]
2020                 str += ['eses', 'es', '', 'is', 'isis'][a + 2]
2021                 if o < 0:
2022                         str += ',' * (-o - 1)
2023                 elif o >= 0:
2024                         str += "'" * (o + 1)
2025
2026                 return '\\transposition %s ' % str
2027
2028
2029         str = re.sub (r"\\set ([A-Za-z]+\s*\.\s*)?transposing\s*=\s*#([-0-9]+)",
2030                       subst, str)
2031         return str
2032
2033 conversions.append (((2,1,27), conv, """property transposing -> tuning"""))
2034
2035 def conv (str):
2036         str = re.sub (r'make-music-by-name', 'make-music', str)
2037         str = re.sub (r"\\override\s+.*Arpeggio\s+#.print-function\s+=\s+\\arpeggioBracket", r"\\arpeggioBracket", str)
2038         return str
2039
2040 conversions.append (((2,1,28), conv,
2041                      """make-music-by-name -> make-music,
2042 new syntax for setting \\arpeggioBracket"""))
2043
2044 def conv (str):
2045         str = re.sub (r'\\center([^-])', '\\center-align\\1', str)
2046         str = re.sub (r'\\translator', '\\context', str)
2047         return str
2048
2049 conversions.append (((2,1,29), conv,
2050                      '\\center -> \\center-align, \\translator -> \\context'))
2051
2052
2053 def conv (str):
2054         str = re.sub (r'\\threeq(flat|sharp)', r'\\sesqui\1', str)
2055         str = re.sub (r'ly:stencil-get-extent',
2056                       'ly:stencil-extent', str)
2057         str = re.sub (r'ly:translator-find',
2058                       'ly:context-find', str)
2059         str = re.sub ('ly:unset-context-property','ly:context-unset-property',
2060                       str)
2061
2062         str = re.sub (r'ly:get-mutable-properties',
2063                       'ly:mutable-music-properties',str)
2064         str = re.sub (r'centralCPosition',
2065                       'middleCPosition',str)
2066         return str
2067
2068 conversions.append (((2,1,30), conv,
2069                      '''\\threeq{flat,sharp} -> \\sesqui{flat,sharp}
2070 ly:get-mutable-properties -> ly:mutable-music-properties
2071 centralCPosition -> middleCPosition
2072 ly:unset-context-property -> ly:context-unset-property
2073 ly:translator-find -> ly:context-find
2074 ly:get-stencil-extent -> ly:stencil-extent
2075 '''))
2076
2077
2078 def conv (str):
2079         str = re.sub (r'\\alias\s*"?Timing"?', '', str)
2080         return str
2081
2082 conversions.append (((2,1,31), conv,
2083                      '''remove \\alias Timing'''))
2084
2085 def conv (str):
2086         str = re.sub (r"(\\set\s+)?(?P<context>(Score\.)?)breakAlignOrder\s*=\s*#'(?P<list>[^\)]+)",
2087                       r"\n\\override \g<context>BreakAlignment #'break-align-orders = "
2088                       + "#(make-vector 3 '\g<list>)", str)
2089
2090         return str
2091
2092 conversions.append (((2,1,33), conv,
2093                      '''breakAlignOrder -> break-align-orders.'''))
2094
2095 def conv (str):
2096         str = re.sub (r"\(set-paper-size",
2097                       "(set-default-paper-size",str)
2098         return str
2099
2100 conversions.append (((2,1,34), conv,
2101                      '''set-paper-size -> set-default-paper-size.'''))
2102
2103 def conv (str):
2104         str = re.sub (r"ly:mutable-music-properties",
2105                       "ly:music-mutable-properties", str)
2106         return str
2107
2108 conversions.append (((2,1, 36), conv,
2109                      '''ly:mutable-music-properties -> ly:music-mutable-properties'''))
2110
2111
2112
2113 def conv (str):
2114         return str
2115
2116 conversions.append (((2, 2, 0), conv,
2117                      '''clean up version. '''))
2118
2119 def conv (str):
2120         return re.sub (r'\\apply\b', r'\\applymusic', str)
2121
2122 conversions.append (((2, 3, 1), conv,
2123                      '''\\apply -> \\applymusic'''))
2124
2125 def conv (str):
2126         if re.search ('textheight', str):
2127                 error_file.write ('\n')
2128                 error_file.write (NOT_SMART % "textheight")
2129                 error_file.write ('\n')
2130                 error_file.write (UPDATE_MANUALLY)
2131                 error_file.write ('\n')
2132                 error_file.write (
2133 """Page layout has been changed, using paper size and margins.
2134 textheight is no longer used.
2135 """)
2136         str = re.sub (r'\\OrchestralScoreContext', '\\Score', str)
2137         def func(m):
2138                 if m.group(1) not in ['RemoveEmptyStaff',
2139                                       'AncientRemoveEmptyStaffContext',
2140                                       'EasyNotation']:
2141                         return '\\' + m.group (1)
2142                 else:
2143                         return m.group (0)
2144
2145
2146         str = re.sub (r'\\([a-zA-Z]+)Context\b', func, str)
2147         str = re.sub ('ly:paper-lookup', 'ly:output-def-lookup', str)
2148         return str
2149
2150 conversions.append (((2, 3, 2), conv,
2151                      '''\\FooContext -> \\Foo'''))
2152
2153 def conv (str):
2154         str = re.sub (r'\\notes\b', '', str)
2155
2156         return str
2157
2158 conversions.append (((2, 3, 4), conv,
2159                      '''remove \\notes'''))
2160
2161
2162
2163 def conv (str):
2164         str = re.sub (r'lastpagefill\s*=\s*"?1"', 'raggedlastbottom = ##t', str)
2165         return str
2166
2167 conversions.append (((2, 3, 6), conv,
2168                      '''lastpagefill -> raggedlastbottom'''))
2169
2170
2171
2172 def conv (str):
2173         str = re.sub (r'\\consistsend', '\\consists', str)
2174         str = re.sub (r'\\lyricsto\s+("?[a-zA-Z]+"?)(\s*\\new Lyrics\s*)?\\lyrics',
2175                       r'\\lyricsto \1 \2', str)
2176         return str
2177
2178 conversions.append (((2, 3, 8), conv,
2179                      '''remove \\consistsend, strip \\lyrics from \\lyricsto.'''))
2180
2181 def conv (str):
2182         str = re.sub (r'neo_mensural', 'neomensural', str)
2183         str = re.sub (r'if-text-padding', 'bound-padding', str)
2184         return str
2185
2186 conversions.append (((2, 3, 9), conv,
2187                      '''neo_mensural -> neomensural, if-text-padding -> bound-padding'''))
2188
2189
2190
2191 def conv (str):
2192         str = re.sub (r'\\addlyrics', r'\\oldaddlyrics', str)
2193         str = re.sub (r'\\newlyrics', r'\\addlyrics', str)
2194         if re.search (r"\\override\s*TextSpanner", str):
2195                 error_file.write ("\nWarning: TextSpanner has been split into DynamicTextSpanner and TextSpanner\n")
2196         return str
2197
2198 conversions.append (((2, 3, 10), conv,
2199                      '''\\addlyrics -> \\oldaddlyrics, \\newlyrics -> \\addlyrics'''))
2200
2201 def conv (str):
2202         str = re.sub (r'\\setMmRestFermata\s+(R[0-9.*/]*)',
2203                       r'\1^\\fermataMarkup', str)
2204         return str
2205
2206 conversions.append (((2, 3, 11), conv,
2207                      '''\\setMmRestFermata -> ^\\fermataMarkup'''))
2208
2209 def conv (str):
2210         str = re.sub (r'\\newpage', r'\\pageBreak', str)
2211         str = re.sub (r'\\scriptUp', r"""{
2212   \\override TextScript  #'direction = #1
2213   \\override Script  #'direction = #1
2214 }""", str)
2215         str = re.sub (r'\\scriptDown', r"""{
2216   \\override TextScript  #'direction = #-1
2217   \\override Script  #'direction = #-1
2218 }""", str)
2219         str = re.sub (r'\\scriptBoth', r"""{
2220   \\revert TextScript  #'direction
2221   \\revert Script  #'direction
2222 }""", str)
2223         str = re.sub ('soloADue', 'printPartCombineTexts', str)
2224         str = re.sub (r'\\applymusic\s*#notes-to-clusters',
2225                       '\\makeClusters', str)
2226
2227         str = re.sub (r'pagenumber\s*=', 'firstpagenumber = ', str)
2228         return str
2229
2230 conversions.append (((2, 3, 12), conv,
2231                      '''\\newpage -> \\pageBreak, junk \\script{up,down,both},
2232 soloADue -> printPartCombineTexts, #notes-to-clusters -> \\makeClusters
2233 '''))
2234
2235
2236 def conv (str):
2237         str = re.sub (r'\\chords\b', r'\\chordmode', str)
2238         str = re.sub (r'\\lyrics\b', r'\\lyricmode', str)
2239         str = re.sub (r'\\figures\b', r'\\figuremode', str)
2240         str = re.sub (r'\\notes\b', r'\\notemode', str)
2241         str = re.sub (r'\\drums\b', r'\\drummode', str)
2242         str = re.sub (r'\\chordmode\s*\\new ChordNames', r'\\chords', str)
2243         str = re.sub (r'\\new ChordNames\s*\\chordmode', r'\\chords', str)
2244         str = re.sub (r'\\new FiguredBass\s*\\figuremode', r'\\figures', str)
2245         str = re.sub (r'\\figuremode\s*\new FiguredBass', r'\\figures', str)
2246         str = re.sub (r'\\new DrumStaff\s*\\drummode', r'\\drums', str)
2247         str = re.sub (r'\\drummode\s*\\new DrumStaff', r'\\drums', str)
2248
2249         return str
2250
2251 conversions.append (((2, 3, 16), conv,
2252                      '''\\foo -> \\foomode (for chords, notes, etc.)
2253 fold \\new FooContext \\foomode into \\foo.'''))
2254
2255 def conv (str):
2256         str = re.sub (r'(slur|stem|phrasingSlur|tie|dynamic|dots|tuplet|arpeggio|)Both', r'\1Neutral', str)
2257         str = re.sub (r"\\applymusic\s*#\(remove-tag\s*'([a-z-0-9]+)\)",
2258                       r"\\removeWithTag #'\1", str)
2259         return str
2260
2261 conversions.append (((2, 3, 17), conv,
2262                      '''\\foo -> \\foomode (for chords, notes, etc.)
2263 fold \\new FooContext \\foomode into \\foo.'''))
2264
2265
2266 def conv (str):
2267         str = re.sub (r'Text_item', 'Text_interface', str)
2268         return str
2269
2270 conversions.append (((2, 3, 18),
2271                      conv,
2272                      '''Text_item -> Text_interface''' ))
2273
2274 def conv (str):
2275         str = re.sub (r'\\paper', r'\\layout', str)
2276         str = re.sub (r'\\bookpaper', r'\\paper', str)
2277         if re.search ('paper-set-staff-size', str):
2278                 error_file.write ('''\nWarning: staff size should be changed at top-level
2279 with
2280
2281   #(set-global-staff-size <STAFF-HEIGHT-IN-POINT>)
2282
2283 ''')
2284
2285
2286         str = re.sub (r'#\(paper-set-staff-size', '%Use set-global-staff-size at toplevel\n% #(layout-set-staff-size', str)
2287         return str
2288
2289 conversions.append (((2, 3, 22),
2290                      conv,
2291                      '''paper -> layout
2292  bookpaper -> paper''' ))
2293
2294
2295 def conv (str):
2296         str = re.sub (r'\\context\s+([a-zA-Z]+)\s*=\s*([a-z]+)\s',
2297                       r'\\context \1 = "\2" ',
2298                       str )
2299         return str
2300
2301 conversions.append (((2, 3, 23),
2302                      conv,
2303                      '''\context Foo = NOTENAME -> \context Foo = "NOTENAME"'''))
2304
2305 def conv (str):
2306         def sub(m):
2307                 return regularize_id (m.group (1))
2308         str = re.sub (r'(maintainer_email|maintainer_web|midi_stuff|gourlay_maxmeasures)',
2309                       sub, str)
2310         return str
2311
2312 conversions.append (((2, 3, 24),
2313                      conv,
2314                      '''regularize other identifiers.'''))
2315
2316
2317 def conv (str):
2318         return str
2319
2320 conversions.append (((2, 4, 0),
2321                      conv,
2322                      ''))
2323
2324
2325 def conv (str):
2326         str = re.sub (r'\\quote\s+"?([a-zA-Z0-9]+)"?\s+([0-9.*/]+)',
2327                       r'\\quoteDuring #"\1" { \skip \2 }',
2328                       str
2329                       )
2330         return str
2331
2332 conversions.append (((2, 5, 0),
2333                      conv,
2334                      ''))
2335
2336
2337 def conv (str):
2338         str = re.sub (r'ly:import-module',
2339                       r'ly:module-copy', str)
2340         return str
2341
2342 conversions.append (((2, 5, 1),
2343                      conv,
2344                      'ly:import-module -> ly:module-copy'))
2345
2346 def conv (str):
2347         str = re.sub (r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
2348                       r'\\\1 {\2}', str)
2349         str = re.sub (r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
2350                       r'\\\1 {\2}', str)
2351         str = re.sub (r'\\(column|fill-line|dir-column|center-align|right-align|left-align|bracketed-y-column)\s*<(([^>]|<[^>]*>)*)>',
2352                       r'\\\1 {\2}', str)
2353         def get_markup (m):
2354                 s = m.group (0)
2355                 s = re.sub (r'''((\\"|})\s*){''', '\2 \\line {', s)
2356                 return s
2357         str = re.sub (r'\\markup\s*{([^}]|{[^}]*})*}', get_markup, str)
2358         return str
2359
2360 conversions.append (((2, 5, 2),
2361                      conv,
2362                      '\markup .. < .. > .. -> \markup .. { .. } ..'))
2363
2364 def conv (str):
2365         str = re.sub ('ly:find-glyph-by-name', 'ly:font-get-glyph', str)
2366         str = re.sub ('"(scripts|clefs|accidentals)-', r'"\1.', str)
2367         str = re.sub ("'hufnagel-do-fa", "'hufnagel.do.fa", str)
2368         str = re.sub ("'(vaticana|hufnagel|medicaea|petrucci|neomensural|mensural)-", r"'\1.", str)
2369         return str
2370
2371 conversions.append (((2, 5, 3),
2372                      conv,
2373                      'ly:find-glyph-by-name -> ly:font-get-glyph, remove - from glyphnames.'))
2374
2375
2376 def conv (str):
2377         str = re.sub (r"\\override\s+(Voice\.)?Slur #'dashed\s*=\s*#\d*(\.\d+)?",
2378                       r"\\slurDashed", str)
2379         return str
2380
2381 conversions.append (((2, 5, 12),
2382                      conv,
2383                      '\set Slur #\'dashed = #X -> \slurDashed'))
2384
2385 def conv (str):
2386         input_encoding = 'latin1'
2387         def func (match):
2388                 encoding = match.group (1)
2389
2390                 # FIXME: automatic recoding of other than latin1?
2391                 if encoding == 'latin1':
2392                         return match.group (2)
2393
2394                 error_file.write ('\n')
2395                 error_file.write (NOT_SMART % ("\\encoding: %s" % encoding))
2396                 error_file.write ('\n')
2397                 error_file.write (_ ("LilyPond source must be UTF-8"))
2398                 error_file.write ('\n')
2399                 if encoding == 'TeX':
2400                         error_file.write (_ ("Try the texstrings backend"))
2401                         error_file.write ('\n')
2402                 else:
2403                         error_file.write ( _("Do something like: %s") % \
2404                                            ("recode %s..utf-8 FILE" % encoding))
2405                         error_file.write ('\n')
2406                 error_file.write (_ ("Or save as UTF-8 in your editor"))
2407                 error_file.write ('\n')
2408                 raise FatalConversionError ()
2409
2410                 return match.group (0)
2411
2412         str = re.sub (r'\\encoding\s+"?([a-zA-Z0-9]+)"?(\s+)', func, str)
2413
2414         import codecs
2415         de_ascii = codecs.getdecoder ('ascii')
2416         de_utf_8 = codecs.getdecoder ('utf_8')
2417         de_input = codecs.getdecoder (input_encoding)
2418         en_utf_8 = codecs.getencoder ('utf_8')
2419         try:
2420                 de_ascii (str)
2421         # only in python >= 2.3
2422         # except UnicodeDecodeError:
2423         except UnicodeError:
2424                 # do not re-recode UTF-8 input
2425                 try:
2426                         de_utf_8 (str)
2427                 #except UnicodeDecodeError:
2428                 except UnicodeError:
2429                         str = en_utf_8 (de_input (str)[0])[0]
2430
2431
2432
2433         str = re.sub (r"#\(ly:set-point-and-click '[a-z-]+\)", '', str)
2434         return str
2435
2436 conversions.append (((2, 5, 13),
2437                      conv,
2438                      '\\encoding: smart recode latin1..utf-8. Remove ly:point-and-click'))
2439
2440
2441 def conv (str):
2442         if re.search ("ly:stencil-set-extent!", str):
2443                 error_file.write ('\n')
2444                 error_file.write (NOT_SMART % "ly:stencil-set-extent!")
2445                 error_file.write ('\n')
2446                 error_file.write ('use (set! VAR (ly:make-stencil (ly:stencil-expr VAR) X-EXT Y-EXT))\n')
2447                 raise FatalConversionError ()
2448         if re.search ("ly:stencil-align-to!", str):
2449                 error_file.write ('\n')
2450                 error_file.write (NOT_SMART % "ly:stencil-align-to!")
2451                 error_file.write ('\n')
2452                 error_file.write ('use (set! VAR (ly:stencil-aligned-to VAR AXIS DIR))\n')
2453                 raise FatalConversionError ()
2454         return str
2455
2456 conversions.append (((2, 5, 17),
2457                      conv,
2458                      'ly:stencil-set-extent! removed'))
2459
2460 def conv (str):
2461         str = re.sub (r"ly:warn\b", 'ly:warning', str)
2462         return str
2463
2464 conversions.append (((2, 5, 18),
2465                      conv,
2466                      'ly:warn -> ly:warning'))
2467 def conv (str):
2468         if re.search ("(override-|revert-)auto-beam-setting", str)\
2469            or re.search ("autoBeamSettings", str):
2470                 error_file.write ('\n')
2471                 error_file.write (NOT_SMART % "auto beam settings")
2472                 error_file.write ('\n')
2473                 error_file.write ('''
2474 Auto beam settings must now specify each interesting moment in a measure
2475 explicitely; 1/4 is no longer multiplied to cover moments 1/2 and 3/4 too.
2476 ''')
2477                 error_file.write (UPDATE_MANUALLY)
2478                 error_file.write ('\n')
2479                 raise FatalConversionError ()
2480         return str
2481
2482 conversions.append (((2, 5, 21),
2483                      conv,
2484                      'warn about auto beam settings'))
2485
2486 def conv (str):
2487         str = re.sub (r"unfoldrepeats", 'unfoldRepeats', str)
2488         str = re.sub (r"compressmusic", 'compressMusic', str)
2489         return str
2490
2491 conversions.append (((2, 5, 25), conv,
2492
2493                      'unfoldrepeats -> unfoldRepeats,'
2494                      + 'compressmusic -> compressMusic'))
2495
2496 def conv (str):
2497         return str
2498
2499 conversions.append (((2, 6, 0), conv,
2500
2501                      'dummy rule for 2.6'))
2502
2503
2504
2505 def conv (str):
2506         return re.sub('ly:get-default-font', 'ly:grob-default-font', str)
2507
2508 conversions.append (((2, 7, 0), conv,
2509                      'ly:get-default-font -> ly:grob-default-font'))
2510
2511 def conv (str):
2512         str = re.sub('ly:parser-define', 'ly:parser-define!', str)
2513         str = re.sub('excentricity', 'eccentricity', str)
2514         str = re.sub(r'\\(consists|remove) *"?Timing_engraver"?',
2515                      r'\\\1 "Timing_translator" \\\1 "Default_bar_line_engraver"',
2516                      str)
2517         return str
2518
2519 conversions.append (((2, 7, 1), conv,
2520                      '''ly:parser-define -> ly:parser-define!
2521 excentricity -> eccentricity
2522 Timing_engraver -> Timing_translator + Default_bar_line_engraver
2523 '''))
2524
2525
2526 def conv (str):
2527         str = re.sub('ly:(add|mul|mod|div)-moment', r'ly:moment-\1', str)
2528         return str
2529
2530 conversions.append (((2, 7, 2), conv,
2531                      '''ly:X-moment -> ly:moment-X'''))
2532
2533
2534 def conv (str):
2535         str = re.sub('keyAccidentalOrder', 'keyAlterationOrder', str)
2536         return str
2537
2538 conversions.append (((2, 7, 4), conv,
2539                      '''keyAccidentalOrder->keyAlterationOrder'''))
2540
2541
2542
2543 def conv (str):
2544         str = re.sub('Performer_group_performer', 'Performer_group', str)
2545         str = re.sub('Engraver_group_engraver', 'Engraver_group', str)
2546         str = re.sub (r"#'inside-slur\s*=\s*##t *",
2547                       r"#'avoid-slur = #'inside ", str)
2548         str = re.sub (r"#'inside-slur\s*=\s*##f *",
2549                       r"#'avoid-slur = #'around ", str)
2550         str = re.sub (r"#'inside-slur",
2551                       r"#'avoid-slur", str)
2552         return str
2553
2554 conversions.append (((2, 7, 6), conv,
2555                      '''Performer_group_performer -> Performer_group, Engraver_group_engraver -> Engraver_group
2556 inside-slur -> avoid-slur'''))
2557
2558
2559
2560 def conv (str):
2561         str = re.sub(r'\\applyoutput', r'\\applyOutput', str)
2562         str = re.sub(r'\\applycontext', r'\\applyContext', str)
2563         str = re.sub(r'\\applymusic',  r'\\applyMusic', str)
2564         str = re.sub(r'ly:grob-suicide', 'ly:grob-suicide!', str)
2565         return str
2566
2567 conversions.append (((2, 7, 10), conv,
2568                      '''\\applyxxx -> \\applyXxx'''))
2569
2570
2571
2572 def conv (str):
2573         str = re.sub(r'\"tabloid\"', '"11x17"', str)
2574         return str
2575
2576 conversions.append (((2, 7, 11), conv,
2577                      '''\"tabloid\" -> \"11x17\"'''))
2578
2579 def conv (str):
2580         str = re.sub(r'outputProperty' , 'overrideProperty', str)
2581         return str
2582
2583 conversions.append (((2, 7, 12), conv,
2584                      '''outputProperty -> overrideProperty'''))
2585
2586
2587 def conv (str):
2588         def subber (match):
2589                 newkey = {'spacing-procedure': 'springs-and-rods',
2590                           'after-line-breaking-callback' : 'after-line-breaking',
2591                           'before-line-breaking-callback' : 'before-line-breaking',
2592                           'print-function' : 'stencil'} [match.group(3)]
2593                 what = match.group (1)
2594                 grob = match.group (2)
2595
2596                 if what == 'revert':
2597                         return "revert %s #'callbacks %% %s\n" % (grob, newkey)
2598                 elif what == 'override':
2599                         return "override %s #'callbacks #'%s" % (grob, newkey)
2600                 else:
2601                         raise 'urg'
2602                         return ''
2603
2604         str = re.sub(r"(override|revert)\s*([a-zA-Z.]+)\s*#'(spacing-procedure|after-line-breaking-callback"
2605                     + r"|before-line-breaking-callback|print-function)",
2606                     subber, str)
2607
2608         if re.search ('bar-size-procedure', str):
2609                 error_file.write (NOT_SMART % "bar-size-procedure")
2610         if re.search ('space-function', str):
2611                 error_file.write (NOT_SMART % "space-function")
2612         if re.search ('verticalAlignmentChildCallback', str):
2613                 error_file.write ('verticalAlignmentChildCallback has been deprecated')
2614         return str
2615
2616 conversions.append (((2, 7, 13), conv,
2617                      '''layout engine refactoring. [FIXME] '''))
2618
2619
2620
2621 def conv (str):
2622         str = re.sub (r"\\override +([A-Z.a-z]+) #'callbacks",
2623                       r"\\override \1", str)
2624         str = re.sub (r"\\revert ([A-Z.a-z]+) #'callbacks % ([a-zA-Z]+)",
2625                       r"\\revert \1 #'\2", str)
2626         str = re.sub (r"([XY]-extent)-callback", r'\1', str)
2627         str = re.sub (r"RemoveEmptyVerticalGroup", "VerticalAxisGroup", str)
2628         str = re.sub (r"\\set ([a-zA-Z]*\.?)minimumVerticalExtent",
2629                       r"\\override \1VerticalAxisGroup #'minimum-Y-extent",
2630                       str)
2631         str = re.sub (r"minimumVerticalExtent",
2632                       r"\\override VerticalAxisGroup #'minimum-Y-extent",
2633                       str)
2634
2635         return str
2636
2637 conversions.append (((2, 7, 14), conv,
2638                      '''Remove callbacks property, deprecate XY-extent-callback. '''))
2639
2640
2641 def conv (str):
2642         if re.search ('[XY]-offset-callbacks', str):
2643                 error_file.write (NOT_SMART % "[XY]-offset-callbacks")
2644         if re.search ('position-callbacks', str):
2645                 error_file.write (NOT_SMART % "position-callbacks")
2646         return str
2647
2648 conversions.append (((2, 7, 15), conv,
2649                      '''Use grob closures iso. XY-offset-callbacks.'''))