2 # -*- coding: utf-8 -*-
4 # once upon a rainy monday afternoon.
6 # This file is part of LilyPond, the GNU music typesetter.
8 # LilyPond is free software: you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation, either version 3 of the License, or
11 # (at your option) any later version.
13 # LilyPond is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
25 # ABC standard v1.6: http://abcnotation.com/
27 # Enhancements (Roy R. Rankin)
29 # Header section moved to top of lilypond file
30 # handle treble, treble-8, alto, and bass clef
31 # Handle voices (V: headers) with clef and part names, multiple voices
32 # Handle w: lyrics with multiple verses
33 # Handle key mode names for minor, major, phrygian, ionian, locrian, aeolian,
34 # mixolydian, lydian, dorian
35 # Handle part names from V: header
36 # Tuplets handling fixed up
37 # Lines starting with |: not discarded as header lines
38 # Multiple T: and C: header entries handled
39 # Accidental maintained until next bar check
40 # Silent rests supported
41 # articulations fermata, upbow, downbow, ltoe, accent, tenuto supported
42 # Chord strings([-^]"string") can contain a '#'
43 # Header fields enclosed by [] in notes string processed
44 # W: words output after tune as abc2ps does it (they failed before)
46 # Enhancements (Laura Conrad)
48 # Barring now preserved between ABC and lilypond
49 # the default placement for text in abc is above the staff.
51 # \breve and \longa supported.
52 # M:none doesn't crash lily.
53 # lilypond '--' supported.
55 # Enhancements (Guy Gascoigne-Piggford)
57 # Add support for maintaining ABC's notion of beaming, this is selectable
58 # from the command line with a -b or --beam option.
59 # Fixd a problem where on cygwin empty lines weren't being correctly identifed
60 # and so were complaining, but still generating the correct output.
64 # Multiple tunes in single file not supported
65 # Blank T: header lines should write score and open a new score
66 # Not all header fields supported
67 # ABC line breaks are ignored
68 # Block comments generate error and are ignored
69 # Postscript commands are ignored
70 # lyrics not resynchronized by line breaks (lyrics must fully match notes)
71 # %%LY slyrics can't be directly before a w: line.
80 # * GNU style messages: warning:FILE:LINE:
83 # Convert to new chord styles.
95 program_name = sys.argv[0]
105 version = '@TOPLEVEL_VERSION@'
106 if version == '@' + 'TOPLEVEL_VERSION' + '@':
107 version = '(unknown version)' # uGUHGUHGHGUGH
113 header['footnotes'] = ''
118 repeat_state = [0] * 8
119 current_voice_idx = -1
120 current_lyric_idx = -1
126 global_key = [0] * 7 # UGH
127 names = ["One", "Two", "Three"]
134 sys.stderr.write (msg)
135 if global_options.strict:
140 return chr (i + ord('A'))
143 # the number gives the base_octave
144 clefs = [("treble", "treble", 0),
145 ("treble1", "french", 0),
146 ("bass3", "varbaritone", 0),
148 ("alto4", "tenor", 0),
149 ("alto2", "mezzosoprano", 0),
150 ("alto1", "soprano", 0),
152 ("perc", "percussion", 0)]
153 modifier = [("-8va", "_8", -1),
163 m = re.match('^'+c[0], s)
165 (clef, octave) = (c[1], c[2])
173 m = re.match('^'+md[0], s)
180 state.base_octave = octave
181 voices_append ("\\clef \""+clef+mod+"\"\n")
184 def select_voice (name, rol):
185 if not voice_idx_dict.has_key (name):
186 state_list.append(Parser_state())
189 voice_idx_dict[name] = len (voices) -1
190 __main__.current_voice_idx = voice_idx_dict[name]
191 __main__.state = state_list[current_voice_idx]
193 m = re.match ('^([^ \t=]*)=(.*)$', rol) # find keywork
197 a = re.match ('^("[^"]*"|[^ \t]*) *(.*)$', rol)
201 if keyword == 'clef':
203 elif keyword == "name":
204 value = re.sub ('\\\\','\\\\\\\\', value)
206 voices_append ("\\set Staff.instrument = %s\n" % value )
208 __main__.part_names = 1
209 elif keyword == "sname" or keyword == "snm":
210 voices_append ("\\set Staff.instr = %s\n" % value )
214 def dump_header (outf,hdr):
215 outf.write ('\\header {\n')
219 hdr[k] = re.sub('"', '\\"', hdr[k])
220 outf.write ('\t%s = "%s"\n'% (k,hdr[k]))
223 def dump_lyrics (outf):
225 outf.write("\n\\score\n{\n \\lyrics\n <<\n")
226 for i in range (len (lyrics)):
227 outf.write ( lyrics [i])
229 outf.write(" >>\n \\layout{}\n}\n")
231 def dump_default_bar (outf):
233 Nowadays abc2ly outputs explicits barlines (?)
236 outf.write ("\n\\set Score.defaultBarType = \"empty\"\n")
239 def dump_slyrics (outf):
240 ks = voice_idx_dict.keys()
243 if re.match('[1-9]', k):
244 m = alphabet (int (k))
247 for i in range (len(slyrics[voice_idx_dict[k]])):
249 outf.write ("\nwords%sV%s = \\lyricmode {" % (m, l))
250 outf.write ("\n" + slyrics [voice_idx_dict[k]][i])
253 def dump_voices (outf):
254 global doing_alternative, in_repeat
255 ks = voice_idx_dict.keys()
258 if re.match ('[1-9]', k):
259 m = alphabet (int (k))
262 outf.write ("\nvoice%s = {" % m)
263 dump_default_bar(outf)
264 if repeat_state[voice_idx_dict[k]]:
265 outf.write("\n\\repeat volta 2 {")
266 outf.write ("\n" + voices [voice_idx_dict[k]])
268 if doing_alternative[voice_idx_dict[k]]:
270 if in_repeat[voice_idx_dict[k]]:
275 #assume that Q takes the form "Q:'opt. description' 1/4=120"
276 #There are other possibilities, but they are deprecated
277 r = re.compile ('^(.*) *([0-9]+) */ *([0-9]+) *=* *([0-9]+)\s*')
280 descr = m.group(1) # possibly empty
281 numerator = int(m.group (2))
282 denominator = int(m.group (3))
284 dur = duration_to_lilypond_duration ((numerator,denominator), 1, 0)
285 voices_append ("\\tempo " + descr + " " + dur + "=" + tempo + "\n")
287 sys.stderr.write("abc2ly: Warning, unable to parse Q specification: %s\n" % a)
289 def dump_score (outf):
296 ks = voice_idx_dict.keys ();
299 if re.match('[1-9]', k):
300 m = alphabet (int (k))
303 if k == 'default' and len (voice_idx_dict) > 1:
305 outf.write ("\n\t\\context Staff=\"%s\"\n\t{\n" %k )
307 outf.write ("\t \\voicedefault\n")
308 outf.write ("\t \\voice%s " % m)
309 outf.write ("\n\t}\n")
312 for lyrics in slyrics [voice_idx_dict[k]]:
313 outf.write ("\n\t\\addlyrics {\n")
314 if re.match('[1-9]',k):
315 m = alphabet (int (k))
319 outf.write ( " \\words%sV%s } " % ( m, chr (l)) )
323 outf.write ("\n\t\\layout {\n")
324 outf.write ("\t}\n\t\\midi {%s}\n}\n" % midi_specs)
328 def set_default_length (s):
329 global length_specified
330 m = re.search ('1/([0-9]+)', s)
332 __main__.default_len = int ( m.group (1))
335 def set_default_len_from_time_sig (s):
336 m = re.search ('([0-9]+)/([0-9]+)', s)
338 n = int (m.group (1))
339 d = int (m.group (2))
340 if (n * 1.0 )/(d * 1.0) < 0.75:
341 __main__.default_len = 16
343 __main__.default_len = 8
352 sys.stderr.write ("cannot open file: `%s'\n" % f)
356 sys.stderr.write ("gulped empty file: `%s'\n" % f)
361 # pitch manipulation. Tuples are (name, alteration).
362 # 0 is (central) C. Alteration -1 is a flat, Alteration +1 is a sharp
363 # pitch in semitones.
364 def semitone_pitch (tup):
374 p = p + t* 2 + tup[1]
377 def fifth_above_pitch (tup):
378 (n, a) = (tup[0] + 4, tup[1])
380 difference = 7 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
391 (t,a) = fifth_above_pitch (p)
392 if semitone_pitch((t,a)) % 12 == 0:
404 (t,a) = quart_above_pitch (p)
405 if semitone_pitch((t,a)) % 12 == 0:
411 def quart_above_pitch (tup):
412 (n, a) = (tup[0] + 3, tup[1])
414 difference = 5 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
419 key_lookup = { # abc to lilypond key mode names
428 'mix' : 'mixolydian',
429 'mixolydian' : 'mixolydian',
444 if k and k[0] == '#':
447 elif k and k[0] == 'b':
451 return '%s \\major' % key
454 if not key_lookup.has_key (type):
455 #ugh, use lilylib, say WARNING:FILE:LINE:
456 sys.stderr.write ("abc2ly:warning:")
457 sys.stderr.write ("ignoring unknown key: `%s'" % orig)
458 sys.stderr.write ('\n')
460 return ("%s \\%s" % ( key, key_lookup[type]))
462 def shift_key (note, acc, shift):
463 s = semitone_pitch((note, acc))
464 s = (s + shift + 12) % 12
476 key_shift = { # semitone shifts for key mode names
499 intkey = (ord (k[0]) - ord('a') + 5) % 7
503 if k and k[0] == 'b':
506 elif k and k[0] == '#':
510 if k and key_shift.has_key(k):
511 (intkey, intkeyacc) = shift_key(intkey, intkeyacc, key_shift[k])
512 keytup = (intkey, intkeyacc)
514 sharp_key_seq = sharp_keys ()
515 flat_key_seq = flat_keys ()
519 if keytup in sharp_key_seq:
521 key_count = sharp_key_seq.index (keytup)
522 accseq = map (lambda x: (4*x -1 ) % 7, range (1, key_count + 1))
524 elif keytup in flat_key_seq:
526 key_count = flat_key_seq.index (keytup)
527 accseq = map (lambda x: (3*x + 3 ) % 7, range (1, key_count + 1))
530 raise Exception ("Huh")
534 key_table[a] = key_table[a] + accsign
549 def try_parse_tuplet_begin (str, state):
550 if re.match ('\([2-9]', str):
553 prev_tuplet_state = state.parsing_tuplet
554 state.parsing_tuplet = int (dig[0])
555 if prev_tuplet_state:
557 voices_append ("\\times %s {" % tup_lookup[dig])
560 def try_parse_group_end (str, state):
561 if str and str[0] in HSPACE:
563 close_beam_state(state)
566 def header_append (key, a):
568 if header.has_key (key):
569 s = header[key] + "\n"
573 linelen = len (v) - v.rfind ('\n')
574 if linelen + len (a) > 80:
578 def stuff_append (stuff, idx, a):
582 stuff [idx] = wordwrap(a, stuff[idx])
584 # ignore wordwrap since we are adding to the previous word
585 def stuff_append_back(stuff, idx, a):
589 point = len(stuff[idx])-1
590 while stuff[idx][point] is ' ':
593 stuff[idx] = stuff[idx][:point] + a + stuff[idx][point:]
595 def voices_append(a):
596 if current_voice_idx < 0:
597 select_voice ('default', '')
598 stuff_append (voices, current_voice_idx, a)
600 # word wrap really makes it hard to bind beams to the end of notes since it
601 # pushes out whitespace on every call. The _back functions do an append
602 # prior to the last space, effectively tagging whatever they are given
604 def voices_append_back(a):
605 if current_voice_idx < 0:
606 select_voice ('default', '')
607 stuff_append_back(voices, current_voice_idx, a)
609 def repeat_prepend():
611 if current_voice_idx < 0:
612 select_voice ('default', '')
614 repeat_state[current_voice_idx] = 't'
617 def lyrics_append(a):
618 a = re.sub ('#', '\\#', a) # latex does not like naked #'s
619 a = re.sub ('"', '\\"', a) # latex does not like naked "'s
620 a = '\t{ "' + a + '" }\n'
621 stuff_append (lyrics, current_lyric_idx, a)
623 # break lyrics to words and put "'s around words containing numbers and '"'s
627 m = re.match('[ \t]*([^ \t]*)[ \t]*(.*$)', str)
631 word = re.sub('"', '\\"', word) # escape "
632 if re.match('.*[0-9"\(]', word):
633 word = re.sub('_', ' ', word) # _ causes probs inside ""
634 ret = ret + '\"' + word + '\" '
636 ret = ret + word + ' '
641 def slyrics_append(a):
642 a = re.sub ( '_', ' _ ', a) # _ to ' _ '
643 a = re.sub ( '([^-])-([^-])', '\\1- \\2', a) # split words with "-" unless was originally "--"
644 a = re.sub ( '\\\\- ', '-', a) # unless \-
645 a = re.sub ( '~', '_', a) # ~ to space('_')
646 a = re.sub ( '\*', '_ ', a) # * to to space
647 a = re.sub ( '#', '\\#', a) # latex does not like naked #'s
648 if re.match('.*[0-9"\(]', a): # put numbers and " and ( into quoted string
650 a = re.sub ( '$', ' ', a) # insure space between lines
651 __main__.lyric_idx = lyric_idx + 1
652 if len(slyrics[current_voice_idx]) <= lyric_idx:
653 slyrics[current_voice_idx].append(a)
655 v = slyrics[current_voice_idx][lyric_idx]
656 slyrics[current_voice_idx][lyric_idx] = wordwrap(a, slyrics[current_voice_idx][lyric_idx])
659 def try_parse_header_line (ln, state):
660 global length_specified
661 m = re.match ('^([A-Za-z]): *(.*)$', ln)
667 a = re.sub('[ \t]*$','', a) #strip trailing blanks
668 if header.has_key('title'):
670 if len(header['title']):
671 # the non-ascii character
672 # in the string below is a
673 # punctuation dash. (TeX ---)
674 header['title'] = header['title'] + ' — ' + a
676 header['subtitle'] = a
681 if not state.common_time:
682 state.common_time = 1
683 voices_append (" \\override Staff.TimeSignature #'style = #'C\n")
686 if not state.common_time:
687 state.common_time = 1
688 voices_append ("\\override Staff.TimeSignature #'style = #'C\n")
690 if not length_specified:
691 set_default_len_from_time_sig (a)
695 voices_append ('\\time %s' % a)
700 m = re.match ('^([^ \t]*) *([^ ]*)( *)(.*)$', a) # separate clef info
702 # there may or may not be a space
703 # between the key letter and the mode
704 # convert the mode to lower-case before comparing
705 mode = m.group(2)[0:3].lower();
706 if key_lookup.has_key(mode):
707 # use the full mode, not only the first three letters
708 key_info = m.group(1) + m.group(2).lower()
709 clef_info = a[m.start(4):]
711 key_info = m.group(1)
712 clef_info = a[m.start(2):]
713 __main__.global_key = compute_key (key_info)
714 k = lily_key (key_info)
716 voices_append ('\\key %s' % k)
717 check_clef(clef_info)
719 __main__.global_key = compute_key (a)
722 voices_append ('\\key %s \\major' % k)
724 header ['footnotes'] = header['footnotes'] + '\\\\\\\\' + a
725 if g == 'O': # Origin
726 header ['origin'] = a
727 if g == 'X': # Reference Number
728 header ['crossRefNumber'] = a
731 if g == 'H': # History
732 header_append ('history', a)
735 if g == 'C': # Composer
736 if header.has_key('composer'):
738 header['composer'] = header['composer'] + '\\\\\\\\' + a
740 header['composer'] = a
742 header ['subtitle'] = a
743 if g == 'L': # Default note length
744 set_default_length (ln)
746 voice = re.sub (' .*$', '', a)
747 rest = re.sub ('^[^ \t]* *', '', a)
749 voices_append(state.next_bar)
751 select_voice (voice, rest)
754 if g == 'w': # vocals
761 # we use in this order specified accidental, active accidental for bar,
762 # active accidental for key
763 def pitch_to_lilypond_name (name, acc, bar_acc, key):
777 return(chr (name + ord('c')) + s)
780 def octave_to_lilypond_quotes (o):
793 while str and str[0] in DIGITS:
794 durstr = durstr + str[0]
803 def duration_to_lilypond_duration (multiply_tup, defaultlen, dots):
805 # (num / den) / defaultlen < 1/base
806 while base * multiply_tup[0] < multiply_tup[1]:
809 if (multiply_tup[0] / multiply_tup[1]) == 2:
811 if (multiply_tup[0] / multiply_tup[1]) == 3:
814 if (multiply_tup[0] / multiply_tup[1]) == 4:
816 return '%s%s' % ( base, '.'* dots)
821 self.next_articulation = ''
825 self.parsing_tuplet = 0
829 self.parsing_beam = 0
833 # return (str, num,den,dots)
834 def parse_duration (str, parser_state):
836 den = parser_state.next_den
837 parser_state.next_den = 1
839 (str, num) = parse_num (str)
845 while str[:1] == '/':
849 (str, d) =parse_num (str)
853 den = den * default_len
855 current_dots = parser_state.next_dots
856 parser_state.next_dots = 0
857 if re.match ('[ \t]*[<>]', str):
858 while str[0] in HSPACE:
862 current_dots = current_dots + 1
863 parser_state.next_den = parser_state.next_den * 2
868 parser_state.next_dots = parser_state.next_dots + 1
876 if num % multiplier == 0 and den % f == 0:
877 num = num / multiplier
879 current_dots = current_dots + d
881 return (str, num,den,current_dots)
884 def try_parse_rest (str, parser_state):
885 if not str or str[0] <> 'z' and str[0] <> 'x':
888 __main__.lyric_idx = -1
890 if parser_state.next_bar:
891 voices_append(parser_state.next_bar)
892 parser_state.next_bar = ''
900 (str, num,den,d) = parse_duration (str, parser_state)
901 voices_append ('%s%s' % (rest, duration_to_lilypond_duration ((num,den), default_len, d)))
902 if parser_state.next_articulation:
903 voices_append (parser_state.next_articulation)
904 parser_state.next_articulation = ''
917 'J' : '', # ignore slide
918 'R' : '', # ignore roll
924 def try_parse_articulation (str, state):
925 while str and artic_tbl.has_key(str[:1]):
926 state.next_articulation = state.next_articulation + artic_tbl[str[:1]]
927 if not artic_tbl[str[:1]]:
928 sys.stderr.write("Warning: ignoring `%s'\n" % str[:1] )
934 # s7m2 input doesn't care about spaces
935 if re.match('[ \t]*\(', str):
939 while str[:1] =='(' and str[1] not in DIGITS:
940 slur_begin = slur_begin + 1
941 state.next_articulation = state.next_articulation + '('
947 # remember accidental for rest of bar
949 def set_bar_acc(note, octave, acc, state):
952 n_oct = note + octave * 7
953 state.in_acc[n_oct] = acc
955 # get accidental set in this bar or UNDEF if not set
956 def get_bar_acc(note, octave, state):
957 n_oct = note + octave * 7
958 if state.in_acc.has_key(n_oct):
959 return(state.in_acc[n_oct])
963 def clear_bar_acc(state):
967 # if we are parsing a beam, close it off
968 def close_beam_state(state):
969 if state.parsing_beam and global_options.beams:
970 state.parsing_beam = 0
971 voices_append_back( ']' )
974 # WAT IS ABC EEN ONTZETTENDE PROGRAMMEERPOEP !
975 def try_parse_note (str, parser_state):
994 octave = parser_state.base_octave
995 if str[0] in "ABCDEFG":
996 str = str[0].lower () + str[1:]
1001 if str[0] in "abcdefg":
1002 notename = (ord(str[0]) - ord('a') + 5)%7
1005 return str # failed; not a note!
1008 __main__.lyric_idx = -1
1010 if parser_state.next_bar:
1011 voices_append(parser_state.next_bar)
1012 parser_state.next_bar = ''
1014 while str[0] == ',':
1017 while str[0] == '\'':
1021 (str, num,den,current_dots) = parse_duration (str, parser_state)
1023 if re.match('[ \t]*\)', str):
1027 while str[:1] ==')':
1028 slur_end = slur_end + 1
1032 bar_acc = get_bar_acc(notename, octave, parser_state)
1033 pit = pitch_to_lilypond_name(notename, acc, bar_acc, global_key[notename])
1034 oct = octave_to_lilypond_quotes (octave)
1035 if acc != UNDEF and (acc == global_key[notename] or acc == bar_acc):
1039 voices_append ("%s%s%s%s" %
1041 duration_to_lilypond_duration ((num,den), default_len, current_dots)))
1043 set_bar_acc(notename, octave, acc, parser_state)
1044 if parser_state.next_articulation:
1045 articulation = articulation + parser_state.next_articulation
1046 parser_state.next_articulation = ''
1048 voices_append (articulation)
1051 voices_append ('-(' * slur_begin )
1053 voices_append ('-)' *slur_end )
1055 if parser_state.parsing_tuplet:
1056 parser_state.parsing_tuplet = parser_state.parsing_tuplet - 1
1057 if not parser_state.parsing_tuplet:
1060 if global_options.beams and \
1061 str[0] in '^=_ABCDEFGabcdefg' and \
1062 not parser_state.parsing_beam and \
1063 not parser_state.parsing_tuplet:
1064 parser_state.parsing_beam = 1
1065 voices_append_back( '[' )
1069 def junk_space (str,state):
1070 while str and str[0] in '\t\n\r ':
1072 close_beam_state(state)
1077 def try_parse_guitar_chord (str, state):
1081 if str[0] == '_' or (str[0] == '^'):
1086 while str and str[0] != '"':
1092 gc = re.sub('#', '\\#', gc) # escape '#'s
1093 state.next_articulation = ("%c\"%s\"" % (position, gc)) \
1094 + state.next_articulation
1097 def try_parse_escape (str):
1098 if not str or str [0] != '\\':
1103 key_table = compute_key ()
1107 # |] thin-thick double bar line
1108 # || thin-thin double bar line
1109 # [| thick-thin double bar line
1112 # :: left-right repeat
1128 '|]' : '\\bar "|."',
1129 '||' : '\\bar "||"',
1130 '[|' : '\\bar "||"',
1132 '|:' : '\\repeat volta 2 {',
1133 '::' : '} \\repeat volta 2 {',
1134 '|1' : '} \\alternative{{',
1141 warn_about = ['|:', '::', ':|', '|1', ':|2', '|2']
1142 alternative_opener = ['|1', '|2', ':|2']
1143 repeat_ender = ['::', ':|']
1144 repeat_opener = ['::', '|:']
1145 in_repeat = [''] * 8
1146 doing_alternative = [''] * 8
1149 def try_parse_bar (str,state):
1150 global in_repeat, doing_alternative, using_old
1153 if current_voice_idx < 0:
1154 select_voice ('default', '')
1155 # first try the longer one
1156 for trylen in [3,2,1]:
1157 if str[:trylen] and bar_dict.has_key (str[:trylen]):
1160 bs = "\\bar \"%s\"" % old_bar_dict[s]
1162 bs = "%s" % bar_dict[s]
1164 if s in alternative_opener:
1165 if not in_repeat[current_voice_idx]:
1167 bs = "\\bar \"%s\"" % old_bar_dict[s]
1169 doing_alternative[current_voice_idx] = 't'
1171 if s in repeat_ender:
1172 if not in_repeat[current_voice_idx]:
1173 sys.stderr.write("Warning: inserting repeat to beginning of notes.\n")
1175 in_repeat[current_voice_idx] = ''
1177 if doing_alternative[current_voice_idx]:
1180 bs = "\\bar \"%s\"" % old_bar_dict[s]
1183 doing_alternative[current_voice_idx] = ''
1184 in_repeat[current_voice_idx] = ''
1185 if s in repeat_opener:
1186 in_repeat[current_voice_idx] = 't'
1188 bs = "\\bar \"%s\"" % old_bar_dict[s]
1193 state.next_bar = '|\n'
1195 clear_bar_acc(state)
1196 close_beam_state(state)
1198 if bs <> None or state.next_bar != '':
1199 if state.parsing_tuplet:
1200 state.parsing_tuplet =0
1201 voices_append ('} ')
1204 clear_bar_acc(state)
1205 close_beam_state(state)
1212 def try_parse_tie (str):
1215 voices_append (' ~ ')
1218 def bracket_escape (str, state):
1219 m = re.match ( '^([^\]]*)] *(.*)$', str)
1223 try_parse_header_line (cmd, state)
1226 def try_parse_chord_delims (str, state):
1229 if re.match('[A-Z]:', str): # bracket escape
1230 return bracket_escape(str, state)
1232 voices_append(state.next_bar)
1234 voices_append ('<<')
1238 if state.plus_chord:
1239 voices_append ('>>')
1240 state.plus_chord = 0
1243 voices_append(state.next_bar)
1245 voices_append ('<<')
1246 state.plus_chord = 1
1254 while str[:1] ==')':
1259 voices_append ("\\spanrequest \\stop \"slur\"" * end)
1263 def try_parse_grace_delims (str, state):
1266 voices_append(state.next_bar)
1269 voices_append ('\\grace { ')
1277 def try_parse_comment (str):
1280 if str[0:5] == '%MIDI':
1281 #the nobarlines option is necessary for an abc to lilypond translator for
1282 #exactly the same reason abc2midi needs it: abc requires the user to enter
1283 #the note that will be printed, and MIDI and lilypond expect entry of the
1284 #pitch that will be played.
1286 #In standard 19th century musical notation, the algorithm for translating
1287 #between printed note and pitch involves using the barlines to determine
1288 #the scope of the accidentals.
1290 #Since ABC is frequently used for music in styles that do not use this
1291 #convention, such as most music written before 1700, or ethnic music in
1292 #non-western scales, it is necessary to be able to tell a translator that
1293 #the barlines should not affect its interpretation of the pitch.
1294 if 'nobarlines' in str:
1296 elif str[0:3] == '%LY':
1297 p = str.find ('voices')
1299 voices_append(str[p+7:])
1301 p = str.find ('slyrics')
1303 slyrics_append(str[p+8:])
1305 #write other kinds of appending if we ever need them.
1310 def parse_file (fn):
1313 ls = map (lambda x: re.sub ("\r$", '', x), ls)
1315 select_voice('default', '')
1318 if not global_options.quiet:
1319 sys.stderr.write ("Line ... ")
1321 __main__.state = state_list[current_voice_idx]
1326 if not (lineno % happy_count):
1327 sys.stderr.write ('[%d]'% lineno)
1329 m = re.match ('^([^%]*)%(.*)$',ln) # add comments to current voice
1332 try_parse_comment(m.group(2))
1333 voices_append ('%% %s\n' % m.group(2))
1338 ln = junk_space (ln, state)
1339 ln = try_parse_header_line (ln, state)
1341 # Try nibbling characters off until the line doesn't change.
1343 while ln != prev_ln:
1345 ln = try_parse_chord_delims (ln, state)
1346 ln = try_parse_rest (ln, state)
1347 ln = try_parse_articulation (ln,state)
1348 ln = try_parse_note (ln, state)
1349 ln = try_parse_bar (ln, state)
1350 ln = try_parse_tie (ln)
1351 ln = try_parse_escape (ln)
1352 ln = try_parse_guitar_chord (ln, state)
1353 ln = try_parse_tuplet_begin (ln, state)
1354 ln = try_parse_group_end (ln, state)
1355 ln = try_parse_grace_delims (ln, state)
1356 ln = junk_space (ln, state)
1359 error ("%s: %d: Huh? Don't understand\n" % (fn, lineno))
1360 left = orig_ln[0:-len (ln)]
1361 sys.stderr.write (left + '\n')
1362 sys.stderr.write (' ' * len (left) + ln + '\n')
1366 if not global_options.quiet:
1367 sys.stderr.write ("%s from LilyPond %s\n" % (program_name, version))
1370 Written by Han-Wen Nienhuys <hanwen@xs4all.nl>, Laura Conrad
1371 <lconrad@laymusic.org>, Roy Rankin <Roy.Rankin@@alcatel.com.au>.
1374 def print_version ():
1375 print r"""abc2ly (GNU lilypond) %s""" % version
1377 def get_option_parser ():
1378 p = ly.get_option_parser (usage=_ ("%s [OPTION]... FILE") % 'abc2ly',
1379 description=_ ('''abc2ly converts ABC music files (see
1380 %s) to LilyPond input.
1381 ''') % 'http://abcnotation.com/abc2mtex/abc.txt',
1382 add_help_option=False)
1384 p.version = "abc2ly (LilyPond) @TOPLEVEL_VERSION@"
1385 p.add_option("--version",
1387 help=_ ("show version number and exit"))
1388 p.add_option("-h", "--help",
1390 help=_ ("show this help and exit"))
1391 p.add_option ("-o", "--output", metavar='FILE',
1393 help=_ ("write output to FILE"))
1394 p.add_option ("-s", "--strict",
1395 action="store_true",
1396 help=_ ("be strict about success"))
1397 p.add_option ('-b', '--beams',
1398 action="store_true",
1399 help=_ ("preserve ABC's notion of beams"))
1400 p.add_option ('-q', '--quiet',
1401 action="store_true",
1402 help=_ ("suppress progress messages"))
1403 p.add_option_group ('',
1405 _ ('Report bugs via %s')
1406 % 'http://post.gmane.org/post.php'
1407 '?group=gmane.comp.gnu.lilypond.bugs') + '\n')
1411 option_parser = get_option_parser ()
1412 (global_options, files) = option_parser.parse_args ()
1417 header['tagline'] = 'Lily was here %s -- automatically converted from ABC' % version
1422 if not global_options.quiet:
1423 sys.stderr.write ('Parsing `%s\'...\n' % f)
1426 if not global_options.output:
1427 global_options.output = os.path.basename (os.path.splitext (f)[0]) + ".ly"
1428 if not global_options.quiet:
1429 sys.stderr.write ('lilypond output to: `%s\'...' % global_options.output)
1430 outf = open (global_options.output, 'w')
1432 # don't substitute @VERSION@. We want this to reflect
1433 # the last version that was verified to work.
1434 outf.write ('\\version "2.7.40"\n')
1436 # dump_global (outf)
1437 dump_header (outf, header)
1442 if not global_options.quiet:
1443 sys.stderr.write ('\n')