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\\markup \\column {\n")
226 for i in range (len (lyrics)):
227 outf.write (lyrics [i])
231 def dump_default_bar (outf):
233 Nowadays abc2ly outputs explicits barlines (?)
236 outf.write ("\n\\set Score.defaultBarType = \"\"\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 # Parsing of numeric tempi, as these are fairly
288 # common. The spec says the number is a "beat" so using
289 # a quarter note as the standard time
290 numericQ = re.compile ('[0-9]+')
291 m = numericQ.match (a)
293 voices_append ("\\tempo 4=" + m.group(0))
295 sys.stderr.write("abc2ly: Warning, unable to parse Q specification: %s\n" % a)
297 def dump_score (outf):
304 ks = voice_idx_dict.keys ();
307 if re.match('[1-9]', k):
308 m = alphabet (int (k))
311 if k == 'default' and len (voice_idx_dict) > 1:
313 outf.write ("\n\t\\context Staff=\"%s\"\n\t{\n" %k )
315 outf.write ("\t \\voicedefault\n")
316 outf.write ("\t \\voice%s " % m)
317 outf.write ("\n\t}\n")
320 for lyrics in slyrics [voice_idx_dict[k]]:
321 outf.write ("\n\t\\addlyrics {\n")
322 if re.match('[1-9]',k):
323 m = alphabet (int (k))
327 outf.write ( " \\words%sV%s } " % ( m, chr (l)) )
331 outf.write ("\n\t\\layout {\n")
332 outf.write ("\t}\n\t\\midi {%s}\n}\n" % midi_specs)
336 def set_default_length (s):
337 global length_specified
338 m = re.search ('1/([0-9]+)', s)
340 __main__.default_len = int ( m.group (1))
343 def set_default_len_from_time_sig (s):
344 m = re.search ('([0-9]+)/([0-9]+)', s)
346 n = int (m.group (1))
347 d = int (m.group (2))
348 if (n * 1.0 )/(d * 1.0) < 0.75:
349 __main__.default_len = 16
351 __main__.default_len = 8
360 sys.stderr.write ("cannot open file: `%s'\n" % f)
364 sys.stderr.write ("gulped empty file: `%s'\n" % f)
369 # pitch manipulation. Tuples are (name, alteration).
370 # 0 is (central) C. Alteration -1 is a flat, Alteration +1 is a sharp
371 # pitch in semitones.
372 def semitone_pitch (tup):
382 p = p + t* 2 + tup[1]
385 def fifth_above_pitch (tup):
386 (n, a) = (tup[0] + 4, tup[1])
388 difference = 7 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
399 (t,a) = fifth_above_pitch (p)
400 if semitone_pitch((t,a)) % 12 == 0:
412 (t,a) = quart_above_pitch (p)
413 if semitone_pitch((t,a)) % 12 == 0:
419 def quart_above_pitch (tup):
420 (n, a) = (tup[0] + 3, tup[1])
422 difference = 5 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
427 key_lookup = { # abc to lilypond key mode names
436 'mix' : 'mixolydian',
437 'mixolydian' : 'mixolydian',
452 if k and k[0] == '#':
455 elif k and k[0] == 'b':
459 return '%s \\major' % key
462 if not key_lookup.has_key (type):
463 #ugh, use lilylib, say WARNING:FILE:LINE:
464 sys.stderr.write ("abc2ly:warning:")
465 sys.stderr.write ("ignoring unknown key: `%s'" % orig)
466 sys.stderr.write ('\n')
468 return ("%s \\%s" % ( key, key_lookup[type]))
470 def shift_key (note, acc, shift):
471 s = semitone_pitch((note, acc))
472 s = (s + shift + 12) % 12
484 key_shift = { # semitone shifts for key mode names
507 intkey = (ord (k[0]) - ord('a') + 5) % 7
511 if k and k[0] == 'b':
514 elif k and k[0] == '#':
518 if k and key_shift.has_key(k):
519 (intkey, intkeyacc) = shift_key(intkey, intkeyacc, key_shift[k])
520 keytup = (intkey, intkeyacc)
522 sharp_key_seq = sharp_keys ()
523 flat_key_seq = flat_keys ()
527 if keytup in sharp_key_seq:
529 key_count = sharp_key_seq.index (keytup)
530 accseq = map (lambda x: (4*x -1 ) % 7, range (1, key_count + 1))
532 elif keytup in flat_key_seq:
534 key_count = flat_key_seq.index (keytup)
535 accseq = map (lambda x: (3*x + 3 ) % 7, range (1, key_count + 1))
538 raise Exception ("Huh")
542 key_table[a] = key_table[a] + accsign
557 def try_parse_tuplet_begin (str, state):
558 if re.match ('\([2-9]', str):
561 prev_tuplet_state = state.parsing_tuplet
562 state.parsing_tuplet = int (dig[0])
563 if prev_tuplet_state:
565 voices_append ("\\times %s {" % tup_lookup[dig])
568 def try_parse_group_end (str, state):
569 if str and str[0] in HSPACE:
571 close_beam_state(state)
574 def header_append (key, a):
576 if header.has_key (key):
577 s = header[key] + "\n"
581 linelen = len (v) - v.rfind ('\n')
582 if linelen + len (a) > 80:
586 def stuff_append (stuff, idx, a):
590 stuff [idx] = wordwrap(a, stuff[idx])
592 # ignore wordwrap since we are adding to the previous word
593 def stuff_append_back(stuff, idx, a):
597 point = len(stuff[idx])-1
598 while stuff[idx][point] is ' ':
601 stuff[idx] = stuff[idx][:point] + a + stuff[idx][point:]
603 def voices_append(a):
604 if current_voice_idx < 0:
605 select_voice ('default', '')
606 stuff_append (voices, current_voice_idx, a)
608 # word wrap really makes it hard to bind beams to the end of notes since it
609 # pushes out whitespace on every call. The _back functions do an append
610 # prior to the last space, effectively tagging whatever they are given
612 def voices_append_back(a):
613 if current_voice_idx < 0:
614 select_voice ('default', '')
615 stuff_append_back(voices, current_voice_idx, a)
617 def repeat_prepend():
619 if current_voice_idx < 0:
620 select_voice ('default', '')
622 repeat_state[current_voice_idx] = 't'
625 def lyrics_append(a):
626 a = re.sub ('#', '\\#', a) # latex does not like naked #'s
627 a = re.sub ('"', '\\"', a) # latex does not like naked "'s
628 a = ' \\line { "' + a + '" }\n'
629 stuff_append (lyrics, current_lyric_idx, a)
631 # break lyrics to words and put "'s around words containing numbers and '"'s
635 m = re.match('[ \t]*([^ \t]*)[ \t]*(.*$)', str)
639 word = re.sub('"', '\\"', word) # escape "
640 if re.match('.*[0-9"\(]', word):
641 word = re.sub('_', ' ', word) # _ causes probs inside ""
642 ret = ret + '\"' + word + '\" '
644 ret = ret + word + ' '
649 def slyrics_append(a):
650 a = re.sub ( '_', ' _ ', a) # _ to ' _ '
651 a = re.sub ( '([^-])-([^-])', '\\1- \\2', a) # split words with "-" unless was originally "--"
652 a = re.sub ( '\\\\- ', '-', a) # unless \-
653 a = re.sub ( '~', '_', a) # ~ to space('_')
654 a = re.sub ( '\*', '_ ', a) # * to to space
655 a = re.sub ( '#', '\\#', a) # latex does not like naked #'s
656 if re.match('.*[0-9"\(]', a): # put numbers and " and ( into quoted string
658 a = re.sub ( '$', ' ', a) # insure space between lines
659 __main__.lyric_idx = lyric_idx + 1
660 if len(slyrics[current_voice_idx]) <= lyric_idx:
661 slyrics[current_voice_idx].append(a)
663 v = slyrics[current_voice_idx][lyric_idx]
664 slyrics[current_voice_idx][lyric_idx] = wordwrap(a, slyrics[current_voice_idx][lyric_idx])
667 def try_parse_header_line (ln, state):
668 global length_specified
669 m = re.match ('^([A-Za-z]): *(.*)$', ln)
675 a = re.sub('[ \t]*$','', a) #strip trailing blanks
676 if header.has_key('title'):
678 if len(header['title']):
679 # the non-ascii character
680 # in the string below is a
681 # punctuation dash. (TeX ---)
682 header['title'] = header['title'] + ' — ' + a
684 header['subtitle'] = a
689 if not state.common_time:
690 state.common_time = 1
691 voices_append (" \\override Staff.TimeSignature #'style = #'C\n")
694 if not state.common_time:
695 state.common_time = 1
696 voices_append ("\\override Staff.TimeSignature #'style = #'C\n")
698 if not length_specified:
699 set_default_len_from_time_sig (a)
703 voices_append ('\\time %s' % a)
708 m = re.match ('^([^ \t]*) *([^ ]*)( *)(.*)$', a) # separate clef info
710 # there may or may not be a space
711 # between the key letter and the mode
712 # convert the mode to lower-case before comparing
713 mode = m.group(2)[0:3].lower();
714 if key_lookup.has_key(mode):
715 # use the full mode, not only the first three letters
716 key_info = m.group(1) + m.group(2).lower()
717 clef_info = a[m.start(4):]
719 key_info = m.group(1)
720 clef_info = a[m.start(2):]
721 __main__.global_key = compute_key (key_info)
722 k = lily_key (key_info)
724 voices_append ('\\key %s' % k)
725 check_clef(clef_info)
727 __main__.global_key = compute_key (a)
730 voices_append ('\\key %s \\major' % k)
732 header ['footnotes'] = header['footnotes'] + '\\\\\\\\' + a
733 if g == 'O': # Origin
734 header ['origin'] = a
735 if g == 'X': # Reference Number
736 header ['crossRefNumber'] = a
739 if g == 'H': # History
740 header_append ('history', a)
743 if g == 'C': # Composer
744 if header.has_key('composer'):
746 header['composer'] = header['composer'] + '\\\\\\\\' + a
748 header['composer'] = a
750 header ['subtitle'] = a
751 if g == 'L': # Default note length
752 set_default_length (ln)
754 voice = re.sub (' .*$', '', a)
755 rest = re.sub ('^[^ \t]* *', '', a)
757 voices_append(state.next_bar)
759 select_voice (voice, rest)
762 if g == 'w': # vocals
766 if g == 'R': # Rhythm (e.g. jig, reel, hornpipe)
768 if g == 'Z': # Transcription (e.g. Steve Mansfield 1/2/2000)
769 header['transcription'] = a
773 # we use in this order specified accidental, active accidental for bar,
774 # active accidental for key
775 def pitch_to_lilypond_name (name, acc, bar_acc, key):
789 return(chr (name + ord('c')) + s)
792 def octave_to_lilypond_quotes (o):
805 while str and str[0] in DIGITS:
806 durstr = durstr + str[0]
815 def duration_to_lilypond_duration (multiply_tup, defaultlen, dots):
817 # (num / den) / defaultlen < 1/base
818 while base * multiply_tup[0] < multiply_tup[1]:
821 if (multiply_tup[0] / multiply_tup[1]) == 2:
823 if (multiply_tup[0] / multiply_tup[1]) == 3:
826 if (multiply_tup[0] / multiply_tup[1]) == 4:
828 return '%s%s' % ( base, '.'* dots)
833 self.next_articulation = ''
837 self.parsing_tuplet = 0
841 self.parsing_beam = 0
845 # return (str, num,den,dots)
846 def parse_duration (str, parser_state):
848 den = parser_state.next_den
849 parser_state.next_den = 1
851 (str, num) = parse_num (str)
857 while str[:1] == '/':
861 (str, d) =parse_num (str)
865 den = den * default_len
867 current_dots = parser_state.next_dots
868 parser_state.next_dots = 0
869 if re.match ('[ \t]*[<>]', str):
870 while str[0] in HSPACE:
874 current_dots = current_dots + 1
875 parser_state.next_den = parser_state.next_den * 2
880 parser_state.next_dots = parser_state.next_dots + 1
888 if num % multiplier == 0 and den % f == 0:
889 num = num / multiplier
891 current_dots = current_dots + d
893 return (str, num,den,current_dots)
896 def try_parse_rest (str, parser_state):
897 if not str or str[0] <> 'z' and str[0] <> 'x':
900 __main__.lyric_idx = -1
902 if parser_state.next_bar:
903 voices_append(parser_state.next_bar)
904 parser_state.next_bar = ''
912 (str, num,den,d) = parse_duration (str, parser_state)
913 voices_append ('%s%s' % (rest, duration_to_lilypond_duration ((num,den), default_len, d)))
914 if parser_state.next_articulation:
915 voices_append (parser_state.next_articulation)
916 parser_state.next_articulation = ''
929 'J' : '', # ignore slide
930 'R' : '', # ignore roll
936 def try_parse_articulation (str, state):
937 while str and artic_tbl.has_key(str[:1]):
938 state.next_articulation = state.next_articulation + artic_tbl[str[:1]]
939 if not artic_tbl[str[:1]]:
940 sys.stderr.write("Warning: ignoring `%s'\n" % str[:1] )
946 # s7m2 input doesn't care about spaces
947 if re.match('[ \t]*\(', str):
951 while str[:1] =='(' and str[1] not in DIGITS:
952 slur_begin = slur_begin + 1
953 state.next_articulation = state.next_articulation + '('
959 # remember accidental for rest of bar
961 def set_bar_acc(note, octave, acc, state):
964 n_oct = note + octave * 7
965 state.in_acc[n_oct] = acc
967 # get accidental set in this bar or UNDEF if not set
968 def get_bar_acc(note, octave, state):
969 n_oct = note + octave * 7
970 if state.in_acc.has_key(n_oct):
971 return(state.in_acc[n_oct])
975 def clear_bar_acc(state):
979 # if we are parsing a beam, close it off
980 def close_beam_state(state):
981 if state.parsing_beam and global_options.beams:
982 state.parsing_beam = 0
983 voices_append_back( ']' )
986 # WAT IS ABC EEN ONTZETTENDE PROGRAMMEERPOEP !
987 def try_parse_note (str, parser_state):
1006 octave = parser_state.base_octave
1007 if str[0] in "ABCDEFG":
1008 str = str[0].lower () + str[1:]
1013 if str[0] in "abcdefg":
1014 notename = (ord(str[0]) - ord('a') + 5)%7
1017 return str # failed; not a note!
1020 __main__.lyric_idx = -1
1022 if parser_state.next_bar:
1023 voices_append(parser_state.next_bar)
1024 parser_state.next_bar = ''
1026 while str[0] == ',':
1029 while str[0] == '\'':
1033 (str, num,den,current_dots) = parse_duration (str, parser_state)
1035 if re.match('[ \t]*\)', str):
1039 while str[:1] ==')':
1040 slur_end = slur_end + 1
1044 bar_acc = get_bar_acc(notename, octave, parser_state)
1045 pit = pitch_to_lilypond_name(notename, acc, bar_acc, global_key[notename])
1046 oct = octave_to_lilypond_quotes (octave)
1047 if acc != UNDEF and (acc == global_key[notename] or acc == bar_acc):
1051 voices_append ("%s%s%s%s" %
1053 duration_to_lilypond_duration ((num,den), default_len, current_dots)))
1055 set_bar_acc(notename, octave, acc, parser_state)
1056 if parser_state.next_articulation:
1057 articulation = articulation + parser_state.next_articulation
1058 parser_state.next_articulation = ''
1060 voices_append (articulation)
1063 voices_append ('-(' * slur_begin )
1065 voices_append ('-)' *slur_end )
1067 if parser_state.parsing_tuplet:
1068 parser_state.parsing_tuplet = parser_state.parsing_tuplet - 1
1069 if not parser_state.parsing_tuplet:
1072 if global_options.beams and \
1073 str[0] in '^=_ABCDEFGabcdefg' and \
1074 not parser_state.parsing_beam and \
1075 not parser_state.parsing_tuplet:
1076 parser_state.parsing_beam = 1
1077 voices_append_back( '[' )
1081 def junk_space (str,state):
1082 while str and str[0] in '\t\n\r ':
1084 close_beam_state(state)
1089 def try_parse_guitar_chord (str, state):
1093 if str[0] == '_' or (str[0] == '^'):
1098 while str and str[0] != '"':
1104 gc = re.sub('#', '\\#', gc) # escape '#'s
1105 state.next_articulation = ("%c\"%s\"" % (position, gc)) \
1106 + state.next_articulation
1109 def try_parse_escape (str):
1110 if not str or str [0] != '\\':
1115 key_table = compute_key ()
1119 # |] thin-thick double bar line
1120 # || thin-thin double bar line
1121 # [| thick-thin double bar line
1124 # :: left-right repeat
1140 '|]' : '\\bar "|."',
1141 '||' : '\\bar "||"',
1142 '[|' : '\\bar "||"',
1144 '|:' : '\\repeat volta 2 {',
1145 '::' : '} \\repeat volta 2 {',
1146 '|1' : '} \\alternative{{',
1153 warn_about = ['|:', '::', ':|', '|1', ':|2', '|2']
1154 alternative_opener = ['|1', '|2', ':|2']
1155 repeat_ender = ['::', ':|']
1156 repeat_opener = ['::', '|:']
1157 in_repeat = [''] * 8
1158 doing_alternative = [''] * 8
1161 def try_parse_bar (str,state):
1162 global in_repeat, doing_alternative, using_old
1165 if current_voice_idx < 0:
1166 select_voice ('default', '')
1167 # first try the longer one
1168 for trylen in [3,2,1]:
1169 if str[:trylen] and bar_dict.has_key (str[:trylen]):
1172 bs = "\\bar \"%s\"" % old_bar_dict[s]
1174 bs = "%s" % bar_dict[s]
1176 if s in alternative_opener:
1177 if not in_repeat[current_voice_idx]:
1179 bs = "\\bar \"%s\"" % old_bar_dict[s]
1181 doing_alternative[current_voice_idx] = 't'
1183 if s in repeat_ender:
1184 if not in_repeat[current_voice_idx]:
1185 sys.stderr.write("Warning: inserting repeat to beginning of notes.\n")
1187 in_repeat[current_voice_idx] = ''
1189 if doing_alternative[current_voice_idx]:
1192 bs = "\\bar \"%s\"" % old_bar_dict[s]
1195 doing_alternative[current_voice_idx] = ''
1196 in_repeat[current_voice_idx] = ''
1197 if s in repeat_opener:
1198 in_repeat[current_voice_idx] = 't'
1200 bs = "\\bar \"%s\"" % old_bar_dict[s]
1205 state.next_bar = '|\n'
1207 clear_bar_acc(state)
1208 close_beam_state(state)
1211 close_beam_state(state)
1213 if bs <> None or state.next_bar != '':
1214 if state.parsing_tuplet:
1215 state.parsing_tuplet =0
1216 voices_append ('} ')
1219 clear_bar_acc(state)
1220 close_beam_state(state)
1227 def try_parse_tie (str):
1230 voices_append (' ~ ')
1233 def bracket_escape (str, state):
1234 m = re.match ( '^([^\]]*)] *(.*)$', str)
1238 try_parse_header_line (cmd, state)
1241 def try_parse_chord_delims (str, state):
1244 if re.match('[A-Z]:', str): # bracket escape
1245 return bracket_escape(str, state)
1247 voices_append(state.next_bar)
1249 voices_append ('<<')
1253 if state.plus_chord:
1254 voices_append ('>>')
1255 state.plus_chord = 0
1258 voices_append(state.next_bar)
1260 voices_append ('<<')
1261 state.plus_chord = 1
1269 while str[:1] ==')':
1274 voices_append ("\\spanrequest \\stop \"slur\"" * end)
1278 def try_parse_grace_delims (str, state):
1281 voices_append(state.next_bar)
1284 voices_append ('\\grace { ')
1292 def try_parse_comment (str):
1295 if str[0:5] == '%MIDI':
1296 #the nobarlines option is necessary for an abc to lilypond translator for
1297 #exactly the same reason abc2midi needs it: abc requires the user to enter
1298 #the note that will be printed, and MIDI and lilypond expect entry of the
1299 #pitch that will be played.
1301 #In standard 19th century musical notation, the algorithm for translating
1302 #between printed note and pitch involves using the barlines to determine
1303 #the scope of the accidentals.
1305 #Since ABC is frequently used for music in styles that do not use this
1306 #convention, such as most music written before 1700, or ethnic music in
1307 #non-western scales, it is necessary to be able to tell a translator that
1308 #the barlines should not affect its interpretation of the pitch.
1309 if 'nobarlines' in str:
1311 elif str[0:3] == '%LY':
1312 p = str.find ('voices')
1314 voices_append(str[p+7:])
1316 p = str.find ('slyrics')
1318 slyrics_append(str[p+8:])
1320 #write other kinds of appending if we ever need them.
1325 def parse_file (fn):
1328 ls = map (lambda x: re.sub ("\r$", '', x), ls)
1330 select_voice('default', '')
1333 if not global_options.quiet:
1334 sys.stderr.write ("Line ... ")
1336 __main__.state = state_list[current_voice_idx]
1341 if not (lineno % happy_count):
1342 sys.stderr.write ('[%d]'% lineno)
1344 m = re.match ('^([^%]*)%(.*)$',ln) # add comments to current voice
1347 try_parse_comment(m.group(2))
1348 voices_append ('%% %s\n' % m.group(2))
1353 ln = junk_space (ln, state)
1354 ln = try_parse_header_line (ln, state)
1356 # Try nibbling characters off until the line doesn't change.
1358 while ln != prev_ln:
1360 ln = try_parse_chord_delims (ln, state)
1361 ln = try_parse_rest (ln, state)
1362 ln = try_parse_articulation (ln,state)
1363 ln = try_parse_note (ln, state)
1364 ln = try_parse_bar (ln, state)
1365 ln = try_parse_tie (ln)
1366 ln = try_parse_escape (ln)
1367 ln = try_parse_guitar_chord (ln, state)
1368 ln = try_parse_tuplet_begin (ln, state)
1369 ln = try_parse_group_end (ln, state)
1370 ln = try_parse_grace_delims (ln, state)
1371 ln = junk_space (ln, state)
1374 error ("%s: %d: Huh? Don't understand\n" % (fn, lineno))
1375 left = orig_ln[0:-len (ln)]
1376 sys.stderr.write (left + '\n')
1377 sys.stderr.write (' ' * len (left) + ln + '\n')
1381 if not global_options.quiet:
1382 sys.stderr.write ("%s from LilyPond %s\n" % (program_name, version))
1385 Written by Han-Wen Nienhuys <hanwen@xs4all.nl>, Laura Conrad
1386 <lconrad@laymusic.org>, Roy Rankin <Roy.Rankin@@alcatel.com.au>.
1389 def print_version ():
1390 print r"""abc2ly (GNU lilypond) %s""" % version
1392 def get_option_parser ():
1393 p = ly.get_option_parser (usage=_ ("%s [OPTION]... FILE") % 'abc2ly',
1394 description=_ ('''abc2ly converts ABC music files (see
1395 %s) to LilyPond input.
1396 ''') % 'http://abcnotation.com/abc2mtex/abc.txt',
1397 add_help_option=False)
1399 p.version = "abc2ly (LilyPond) @TOPLEVEL_VERSION@"
1400 p.add_option("--version",
1402 help=_ ("show version number and exit"))
1403 p.add_option("-h", "--help",
1405 help=_ ("show this help and exit"))
1406 p.add_option ("-o", "--output", metavar='FILE',
1408 help=_ ("write output to FILE"))
1409 p.add_option ("-s", "--strict",
1410 action="store_true",
1411 help=_ ("be strict about success"))
1412 p.add_option ('-b', '--beams',
1413 action="store_true",
1414 help=_ ("preserve ABC's notion of beams"))
1415 p.add_option ('-q', '--quiet',
1416 action="store_true",
1417 help=_ ("suppress progress messages"))
1418 p.add_option_group ('',
1420 _ ('Report bugs via %s')
1421 % 'http://post.gmane.org/post.php'
1422 '?group=gmane.comp.gnu.lilypond.bugs') + '\n')
1426 option_parser = get_option_parser ()
1427 (global_options, files) = option_parser.parse_args ()
1432 header['tagline'] = 'Lily was here %s -- automatically converted from ABC' % version
1437 if not global_options.quiet:
1438 sys.stderr.write ('Parsing `%s\'...\n' % f)
1441 if not global_options.output:
1442 global_options.output = os.path.basename (os.path.splitext (f)[0]) + ".ly"
1443 if not global_options.quiet:
1444 sys.stderr.write ('lilypond output to: `%s\'...' % global_options.output)
1445 outf = open (global_options.output, 'w')
1447 # don't substitute @VERSION@. We want this to reflect
1448 # the last version that was verified to work.
1449 outf.write ('\\version "2.7.40"\n')
1451 # dump_global (outf)
1452 dump_header (outf, header)
1457 if not global_options.quiet:
1458 sys.stderr.write ('\n')