# * lilylib
# * GNU style messages: warning:FILE:LINE:
# * l10n
-#
+#
# Convert to new chord styles.
#
# UNDEF -> None
#
-
+
import __main__
import getopt
version = '@TOPLEVEL_VERSION@'
if version == '@' + 'TOPLEVEL_VERSION' + '@':
- version = '(unknown version)' # uGUHGUHGHGUGH
+ version = '(unknown version)' # uGUHGUHGHGUGH
UNDEF = 255
state = UNDEF
def alphabet (i):
return chr (i + ord('A'))
-
+
def check_clef(s):
# the number gives the base_octave
clefs = [("treble", "treble", 0),
value = re.sub ('\\\\','\\\\\\\\', value)
## < 2.2
voices_append ("\\set Staff.instrument = %s\n" % value )
-
+
__main__.part_names = 1
elif keyword == "sname" or keyword == "snm":
voices_append ("\\set Staff.instr = %s\n" % value )
ks = hdr.keys ()
ks.sort ()
for k in ks:
- hdr[k] = re.sub('"', '\\"', hdr[k])
+ hdr[k] = re.sub('"', '\\"', hdr[k])
outf.write ('\t%s = "%s"\n'% (k,hdr[k]))
outf.write ('}')
m = k
if k == 'default' and len (voice_idx_dict) > 1:
break
- outf.write ("\n\t\\context Staff=\"%s\"\n\t{\n" %k )
+ outf.write ("\n\t\\context Staff=\"%s\"\n\t{\n" %k )
if k != 'default':
outf.write ("\t \\voicedefault\n")
outf.write ("\t \\voice%s " % m)
# pitch manipulation. Tuples are (name, alteration).
# 0 is (central) C. Alteration -1 is a flat, Alteration +1 is a sharp
-# pitch in semitones.
+# pitch in semitones.
def semitone_pitch (tup):
p =0
t = tup[0]
p = p + 12 * (t / 7)
t = t % 7
-
+
if t > 2:
p = p- 1
-
+
p = p + t* 2 + tup[1]
return p
difference = 7 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
a = a + difference
-
+
return (n,a)
def sharp_keys ():
difference = 5 - (semitone_pitch ((n,a)) - semitone_pitch (tup))
a = a + difference
-
+
return (n,a)
key_lookup = { # abc to lilypond key mode names
'm' : 'minor',
'min' : 'minor',
'maj' : 'major',
- 'major' : 'major',
+ 'major' : 'major',
'phr' : 'phrygian',
'ion' : 'ionian',
'loc' : 'locrian',
'aeo' : 'aeolian',
'mix' : 'mixolydian',
- 'mixolydian' : 'mixolydian',
+ 'mixolydian' : 'mixolydian',
'lyd' : 'lydian',
'dor' : 'dorian',
- 'dorian' : 'dorian'
+ 'dorian' : 'dorian'
}
def lily_key (k):
'min' : 3,
'minor' : 3,
'maj' : 0,
- 'major' : 0,
+ 'major' : 0,
'phr' : -4,
'phrygian' : -4,
'ion' : 0,
'ionian' : 0,
'loc' : 1,
- 'locrian' : 1,
+ 'locrian' : 1,
'aeo' : 3,
'aeolian' : 3,
'mix' : 5,
- 'mixolydian' : 5,
+ 'mixolydian' : 5,
'lyd' : -5,
- 'lydian' : -5,
+ 'lydian' : -5,
'dor' : -2,
- 'dorian' : -2
+ 'dorian' : -2
}
def compute_key (k):
k = k.lower ()
intkey = (ord (k[0]) - ord('a') + 5) % 7
intkeyacc =0
k = k[1:]
-
+
if k and k[0] == 'b':
intkeyacc = -1
k = k[1:]
if k and key_shift.has_key(k):
(intkey, intkeyacc) = shift_key(intkey, intkeyacc, key_shift[k])
keytup = (intkey, intkeyacc)
-
+
sharp_key_seq = sharp_keys ()
flat_key_seq = flat_keys ()
else:
error ("Huh?")
raise Exception ("Huh")
-
+
key_table = [0] * 7
for a in accseq:
key_table[a] = key_table[a] + accsign
prev_tuplet_state = state.parsing_tuplet
state.parsing_tuplet = int (dig[0])
if prev_tuplet_state:
- voices_append ("}")
+ voices_append ("}")
voices_append ("\\times %s {" % tup_lookup[dig])
return str
str = str[1:]
close_beam_state(state)
return str
-
+
def header_append (key, a):
s = ''
if header.has_key (key):
if not using_old:
repeat_state[current_voice_idx] = 't'
-
+
def lyrics_append(a):
a = re.sub ('#', '\\#', a) # latex does not like naked #'s
a = re.sub ('"', '\\"', a) # latex does not like naked "'s
def slyrics_append(a):
a = re.sub ( '_', ' _ ', a) # _ to ' _ '
- a = re.sub ( '([^-])-([^-])', '\\1- \\2', a) # split words with "-" unless was originally "--"
+ a = re.sub ( '([^-])-([^-])', '\\1- \\2', a) # split words with "-" unless was originally "--"
a = re.sub ( '\\\\- ', '-', a) # unless \-
a = re.sub ( '~', '_', a) # ~ to space('_')
a = re.sub ( '\*', '_ ', a) # * to to space
header ['subtitle'] = a
if g == 'L': # Default note length
set_default_length (ln)
- if g == 'V': # Voice
+ if g == 'V': # Voice
voice = re.sub (' .*$', '', a)
rest = re.sub ('^[^ \t]* *', '', a)
if state.next_bar:
s = 'es'
elif acc == 1:
s = 'is'
-
+
if name > 4:
name = name -7
return(chr (name + ord('c')) + s)
-# return (str, num,den,dots)
+# return (str, num,den,dots)
def parse_duration (str, parser_state):
num = 0
den = parser_state.next_den
den = den * d
den = den * default_len
-
+
current_dots = parser_state.next_dots
parser_state.next_dots = 0
if re.match ('[ \t]*[<>]', str):
str = str [1:]
current_dots = current_dots + 1
parser_state.next_den = parser_state.next_den * 2
-
+
while str[0] == '<':
str = str [1:]
den = den * 2
num = num / multiplier
den = den / f
current_dots = current_dots + d
-
+
return (str, num,den,current_dots)
'O' : '^\\coda',
'v' : '^\\downbow'
}
-
+
def try_parse_articulation (str, state):
while str and artic_tbl.has_key(str[:1]):
state.next_articulation = state.next_articulation + artic_tbl[str[:1]]
str = str[1:]
-
-
+
+
# s7m2 input doesnt care about spaces
if re.match('[ \t]*\(', str):
str = str.lstrip ()
str = str[1:]
return str
-
+
#
# remember accidental for rest of bar
#
state.parsing_beam = 0
voices_append_back( ']' )
-
+
# WAT IS ABC EEN ONTZETTENDE PROGRAMMEERPOEP !
def try_parse_note (str, parser_state):
mud = ''
else:
return str # failed; not a note!
-
+
__main__.lyric_idx = -1
if parser_state.next_bar:
if re.match('[ \t]*\)', str):
str = str.lstrip ()
-
+
slur_end =0
while str[:1] ==')':
slur_end = slur_end + 1
str = str[1:]
-
+
bar_acc = get_bar_acc(notename, octave, parser_state)
pit = pitch_to_lilypond_name(notename, acc, bar_acc, global_key[notename])
oct = octave_to_lilypond_quotes (octave)
voices_append ("%s%s%s%s" %
(pit, oct, mod,
duration_to_lilypond_duration ((num,den), default_len, current_dots)))
-
+
set_bar_acc(notename, octave, acc, parser_state)
if parser_state.next_articulation:
articulation = articulation + parser_state.next_articulation
not parser_state.parsing_tuplet:
parser_state.parsing_beam = 1
voices_append_back( '[' )
-
+
return str
def junk_space (str,state):
while str and str[0] != '"':
gc = gc + str[0]
str = str[1:]
-
+
if str:
str = str[1:]
gc = re.sub('#', '\\#', gc) # escape '#'s
def try_parse_escape (str):
if not str or str [0] != '\\':
return str
-
+
str = str[1:]
if str[:1] =='K':
key_table = compute_key ()
str = str[1:]
clear_bar_acc(state)
close_beam_state(state)
-
+
if bs <> None or state.next_bar != '':
if state.parsing_tuplet:
state.parsing_tuplet =0
voices_append ('} ')
-
+
if bs <> None:
clear_bar_acc(state)
close_beam_state(state)
end = end + 1
str = str[1:]
-
+
voices_append ("\\spanrequest \\stop \"slur\"" * end)
voices_append (ch)
return str
#Since ABC is frequently used for music in styles that do not use this
#convention, such as most music written before 1700, or ethnic music in
#non-western scales, it is necessary to be able to tell a translator that
-#the barlines should not affect its interpretation of the pitch.
+#the barlines should not affect its interpretation of the pitch.
if 'nobarlines' in str:
nobarlines = 1
elif str[0:3] == '%LY':
p = str.find ('slyrics')
if (p > -1):
slyrics_append(str[p+8:])
-
-#write other kinds of appending if we ever need them.
+
+#write other kinds of appending if we ever need them.
return str
lineno = 0
sys.stderr.write ("Line ... ")
sys.stderr.flush ()
__main__.state = state_list[current_voice_idx]
-
+
for ln in ls:
lineno = lineno + 1
ln = m.group (1)
orig_ln = ln
-
+
ln = try_parse_header_line (ln, state)
# Try nibbling characters off until the line doesn't change.
error ("%s: %d: Huh? Don't understand\n" % (fn, lineno))
left = orig_ln[0:-len (ln)]
sys.stderr.write (left + '\n')
- sys.stderr.write (' ' * len (left) + ln + '\n')
+ sys.stderr.write (' ' * len (left) + ln + '\n')
def identify():
dump_score (outf)
dump_lyrics (outf)
sys.stderr.write ('\n')
-
projects / lilypond.git / commitdiff