spiffyscore

Changes On Branch 3023a967c2f9c9a8
Login

Changes On Branch 3023a967c2f9c9a8

Patch Side-by-Side Diff

Changes In Branch develop Excluding Merge-Ins

This is equivalent to a diff from 689adc054e to 3023a967c2

2011-12-04
20:52
Made room for arbitrary-note chording whenever I figure out the CFY to represent iTSYntax to use for it Leaf check-in: 3023a967c2 user: brian tags: develop
2011-11-27
02:56
Fixed chord support check-in: 8f28834102 user: brian tags: develop
2011-06-12
20:32
Made some changes to the parser. Don't remember what. Leaf check-in: 87435601e4 user: brian tags: master
20:31
Create new branch named "develop" check-in: 9f4c4666c5 user: brian tags: develop
2011-02-10
23:50
Program generates a render order for the instruments based on their sync order check-in: 689adc054e user: brian@linux-85dd.site tags: master
22:34
Added lexical support for parens instead of quotes for chords, cleaned up the yacc parser, added lex tokens for syncopation check-in: 702d933446 user: brian@linux-85dd.site tags: master

Deleted cfg.orc version [9f49be1cae].
Deleted cfg.py version [e9b556b4f3].
Deleted cfg.sco version [c92bf3908c].
Modified parse.py from [3ec57c3fbe] to [2894767aa0]. 
1


2
3
4
5
6
7






8
9
10
11
12
13
14
15


16
17
18
19
20

21
22
23

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

39

40
41
42
43
44
45
46



47
48
49
50

51

52
53
54
55
56
57
58

1
2
3
4
5
6



7
8
9
10
11
12
13

14
15
16
17


18
19
20


21

22
23
24

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

40
41
42
43
44
45
46



47
48
49
50
51
52

53
54
55
56
57
58
59
60
61
62


+
+



-
-
-
+
+
+
+
+
+

-




-
-
+
+

-
-

-
+


-
+














-
+

+




-
-
-
+
+
+



-
+

+








#!/usr/bin/env python

import tree

from ply import lex, yacc
class Note():
    def __init__(self, value, duration=.25, octave=8):
        self.value = value
        self.duration = duration
    def __init__(self, value, duration=1, octave=8):
        self.duration = duration
        if value > 12:
            self.duration += 1
            value = value % 12
        self.value = value
        self.octave = octave
        self.accidental = None
    def __repr__(self):
        return "Note %s %s %s" % (self.value, self.duration, self.octave)

class Chord():
    def __init__(self, value, duration=.5, chord_type="major", octave=5):
        self.value = value
    def __init__(self, notes, duration=1):
        self.notes = notes
        self.duration = duration
        self.chord_type = chord_type
        self.octave = octave
    def __repr__(self):
        return "Chord %s %s %s" % (self.value, self.duration, self.chord_type, self.octave)
        return "Chord %s" % (self.notes)

class Rest():
    def __init__(self, duration=.25):
    def __init__(self, duration=1):
        self.duration = duration
    def __repr__(self):
        return "Rest node %s" % self.duration


def parse(score, default_octave=8):
    # Tokenize (lex)
    tokens = (
        "NOTE_LENGTH",
        "BASENOTE",
        "ACCIDENTAL",
        "REST",
        "OCTAVE",
        "CHORD_TYPE",
        "PAREN",
        "BRACKET",
        "SYNCOPATE",
        "NODE",
    )

    t_ignore = " |"

    #t_BASENOTE = r"[A-Ga-g]"
    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    t_ACCIDENTAL = r"\^{1,2}|_{1,2}|="
    t_BASENOTE = r"[A-Ga-g]"
#    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    t_ACCIDENTAL = r"\^{1}|_{1}|="
    t_REST = r"z"
    t_OCTAVE = r"'+|,+"
    t_CHORD_TYPE = r"m|7|m7|0|o|\+|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    t_PAREN = "\(|\)"
    t_BRACKET = r"\[|\]"
    t_SYNCOPATE = "\+|-"
    t_NODE = r"\([a-zA-Z0-9_-]+\)"

    def t_NOTE_LENGTH(t):
        r"/?\d+"
        multiplier = float(t.value.strip("/"))
        if t.value.startswith("/"):
            multiplier = 1/multiplier
        t.value = multiplier
︙
67
68
69
70
71
72
73

74
75
76
77
78
79
80

81
82
83
84
85
86
87

71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93








+







+









    # Parse (yacc)

    def p_note_list(p):
        '''score : score note
                 | score chord
                 | score rest
            | score node
        '''
        p[0] = p[1] + [p[2]]

    def p_score(p):
        '''score : note
                 | chord
                 | rest
            | node
        '''
        p[0] = [p[1]]


    def p_chord_length(p):
        ''' chord : chord NOTE_LENGTH
        '''
︙
95
96
97
98
99
100
101
102
103


104



105
106
107
108
109









110
111
112
113
114
115
116
117
118
119
120
121




122
123
124
125
126
127
128
129
130
131
132
133
134










135

136
137
138
139
140
141
142
143
144






145



146
147
148
149
150

101
102
103
104
105
106
107


108
109
110
111
112
113





114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185








-
-
+
+

+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+











-
+
+
+
+













+
+
+
+
+
+
+
+
+
+
-
+









+
+
+
+
+
+

+
+
+






        '''
        new_note = p[1]
        new_note.duration = p[2]
        p[0] = new_note


    def p_chord(p):
        '''chord : PAREN note PAREN
                 | PAREN note CHORD_TYPE PAREN
        '''chord : BRACKET note BRACKET
                 | BRACKET note CHORD_TYPE BRACKET
        '''

        if len(p) > 3:
            chorded_notes = []
        pitch = p[2].value
        pitch = pitch.upper()
        p[0] = Chord(value=pitch, octave=default_octave)
        if len(p) > 3:
            p[0].chord_type = p[3]
            root_note = p[2].value
            for offset in [0, 4, 7]:
                chorded_notes.append(Note(root_note+offset, octave=p[2].octave))
            chord = Chord(notes=chorded_notes)
        else:  # This won'k work until the grammar is modified to rocognise multiple notes botween brackets
            chord = p[1:-2]
                

        p[0] = chord


    def p_note_syncopate(p):
        ''' note : note SYNCOPATE
        '''
        note.syncopate = p[2]


    def p_accidental(p):
        '''note : ACCIDENTAL note
        '''
        p[2].accidental = p[1]
        if p[1] == "^":
            p[2].value += 1
        else:
            p[2].value -= 1
        p[0] = p[2]

    def p_octave(p):
        '''note : note OCTAVE
        '''
        count = len(p[2])
        increment_or_decrement = 1 if p[2].startswith("'") else -1
        p[1].octave += (count * increment_or_decrement)
        p[0] = p[1]

    def p_note(p):
        '''note : BASENOTE
        '''
        notes = {
            "C": 0,
            "D": 2,
            "E": 4,
            "F": 5,
            "G": 7,
            "A": 9,
            "B": 11
        }
        n = notes[p[1]]
        p[0] = Note(p[1], octave=default_octave)
        p[0] = Note(n, octave=default_octave)

    def p_rest(p):
        ''' rest : REST
                 | REST NOTE_LENGTH
        '''
        p[0] = Rest()
        if len(p) > 2:
            p[0].duration = p[2]

    def p_node(p):
        '''node : NODE
        '''
        p[0] = tree.Tree(p[1].strip("(").strip(")"))


    def p_error(p):
#        import ipdb
#        ipdb.set_trace()
        print p
        raise Exception("Syntax error at '%s' of element type %s" % (p.value, p.type))
        
    yacc.yacc()

    return yacc.parse(score)
Added score.yaml version [29fd4ba47c].
Added spiffyscore.py version [1f857f673d].
Deleted test.sco version [c92bf3908c].
Deleted todo.org version [510751b73f].
Added tree.py version [29c78902c8].