Drop the enumerated pitch values.

It's really just as easy to use macros such as PITCH_LITERAL,
PITCH_NAME, or PITCH_ACCIDENTAL in some combination instead of using
an enumerated pitch_t value.

In place of the enum, we now have pitch_t as a uint32_t type.

The real purpose for doing this is to prepare for pitch_t to be able
to hold the octave as well which should be remarkably convenient.

diff --git a/pitch.h b/pitch.h
index 13c29057bf5d25272d438e427d5c0f2c3ca4223d..525f14c8ae5038426bfe97c0c879ee8c67a3d637 100644 (file)
--- a/pitch.h
+++ b/pitch.h
@@ -18,6 +18,11 @@
  * along with this program.  If not, see http://www.gnu.org/licenses/ .
  */
 
+#include <stdint.h>
+
+#ifndef PITCH_H
+#define PITCH_H
+
 #define PITCH_ACCIDENTAL_MASK 0x07
 #define PITCH_ACCIDENTAL_SHIFT 0
 
@@ -51,48 +56,8 @@ typedef enum pitch_name
 #define PITCH(name, accidental) (((name) << PITCH_NAME_SHIFT) | (accidental))
 
 #define PITCH_LITERAL(literal_name, literal_accidental) PITCH(PITCH_NAME_##literal_name, PITCH_ACCIDENTAL_##literal_accidental)
+#define PITCH_NATURAL(literal_name) PITCH_LITERAL(literal_name, NATURAL)
 
-typedef enum pitch
-{
-    PITCH_Cff = PITCH_LITERAL (C, DOUBLE_FLAT), 
-    PITCH_Cf  = PITCH_LITERAL (C, FLAT),         
-    PITCH_C   = PITCH_LITERAL (C, NATURAL),      
-    PITCH_Cs  = PITCH_LITERAL (C, SHARP),        
-    PITCH_Css = PITCH_LITERAL (C, DOUBLE_SHARP),
-
-    PITCH_Dff = PITCH_LITERAL (D, DOUBLE_FLAT), 
-    PITCH_Df  = PITCH_LITERAL (D, FLAT),         
-    PITCH_D   = PITCH_LITERAL (D, NATURAL),      
-    PITCH_Ds  = PITCH_LITERAL (D, SHARP),        
-    PITCH_Dss = PITCH_LITERAL (D, DOUBLE_SHARP),
-
-    PITCH_Eff = PITCH_LITERAL (E, DOUBLE_FLAT), 
-    PITCH_Ef  = PITCH_LITERAL (E, FLAT),         
-    PITCH_E   = PITCH_LITERAL (E, NATURAL),      
-    PITCH_Es  = PITCH_LITERAL (E, SHARP),        
-    PITCH_Ess = PITCH_LITERAL (E, DOUBLE_SHARP),
-
-    PITCH_Fff = PITCH_LITERAL (F, DOUBLE_FLAT), 
-    PITCH_Ff  = PITCH_LITERAL (F, FLAT),         
-    PITCH_F   = PITCH_LITERAL (F, NATURAL),      
-    PITCH_Fs  = PITCH_LITERAL (F, SHARP),        
-    PITCH_Fss = PITCH_LITERAL (F, DOUBLE_SHARP),
-
-    PITCH_Gff = PITCH_LITERAL (G, DOUBLE_FLAT), 
-    PITCH_Gf  = PITCH_LITERAL (G, FLAT),         
-    PITCH_G   = PITCH_LITERAL (G, NATURAL),      
-    PITCH_Gs  = PITCH_LITERAL (G, SHARP),        
-    PITCH_Gss = PITCH_LITERAL (G, DOUBLE_SHARP),
-
-    PITCH_Aff = PITCH_LITERAL (A, DOUBLE_FLAT), 
-    PITCH_Af  = PITCH_LITERAL (A, FLAT),         
-    PITCH_A   = PITCH_LITERAL (A, NATURAL),      
-    PITCH_As  = PITCH_LITERAL (A, SHARP),        
-    PITCH_Ass = PITCH_LITERAL (A, DOUBLE_SHARP),
+typedef uint32_t pitch_t;
 
-    PITCH_Bff = PITCH_LITERAL (B, DOUBLE_FLAT), 
-    PITCH_Bf  = PITCH_LITERAL (B, FLAT),         
-    PITCH_B   = PITCH_LITERAL (B, NATURAL),      
-    PITCH_Bs  = PITCH_LITERAL (B, SHARP),        
-    PITCH_Bss = PITCH_LITERAL (B, DOUBLE_SHARP)
-} pitch_t;
+#endif /* PITCH_H */

diff --git a/scherzo.c b/scherzo.c
index 1f2fed753fae1aacefbd706b5cdfb7a5142dd9ad..d3ca62843fa1e0beb4921b3a2c3c887e66af4119 100644 (file)
--- a/scherzo.c
+++ b/scherzo.c
@@ -148,7 +148,7 @@ on_key_press_event (GtkWidget *widget,
     scherzo_t *scherzo = user_data;
     int octave;
     /* Initialize to keep the compiler quiet. */
-    pitch_name_t pitch_name = PITCH_C;
+    pitch_name_t pitch_name = PITCH_NATURAL (C);
     pitch_t pitch;
 
     if (scherzo->challenge.note)
@@ -375,40 +375,40 @@ _midi_to_pitch_and_octave (unsigned char midi_note,
     switch (midi_note % 12)
     {
     case 0:
-       *pitch = PITCH_C;
+       *pitch = PITCH_LITERAL (C, NATURAL);
        break;
     case 1:
-       *pitch = PITCH_Cs;
+       *pitch = PITCH_LITERAL (C, SHARP);
        break;
     case 2:
-       *pitch = PITCH_D;
+       *pitch = PITCH_LITERAL (D, NATURAL);
        break;
     case 3:
-       *pitch = PITCH_Ds;
+       *pitch = PITCH_LITERAL (D, SHARP);
        break;
     case 4:
-       *pitch = PITCH_E;
+       *pitch = PITCH_LITERAL (E, NATURAL);
        break;
     case 5:
-       *pitch = PITCH_F;
+       *pitch = PITCH_LITERAL (F, NATURAL);
        break;
     case 6:
-       *pitch = PITCH_Fs;
+       *pitch = PITCH_LITERAL (F, SHARP);
        break;
     case 7:
-       *pitch = PITCH_G;
+       *pitch = PITCH_LITERAL (G, NATURAL);
        break;
     case 8:
-       *pitch = PITCH_Gs;
+       *pitch = PITCH_LITERAL (G, SHARP);
        break;
     case 9:
-       *pitch = PITCH_A;
+       *pitch = PITCH_LITERAL (A, NATURAL);
        break;
     case 10:
-       *pitch = PITCH_As;
+       *pitch = PITCH_LITERAL (A, SHARP);
        break;
     case 11:
-       *pitch = PITCH_B;
+       *pitch = PITCH_LITERAL (B, NATURAL);
        break;
     }
 }
@@ -560,81 +560,56 @@ _chord_signature_matches (analyzed_note_t *notes,
 static const char *
 _pitch_str (pitch_t pitch)
 {
-    switch (pitch) {
-    case PITCH_Cff:
-       return "C𝄫";
-    case PITCH_Cf:
-       return "C♭";
-    case PITCH_C:
-       return "C";
-    case PITCH_Cs:
-       return "C♯";
-    case PITCH_Css:
-       return "C𝄪";
-    case PITCH_Dff:
-       return "D𝄫";
-    case PITCH_Df:
-       return "D♭";
-    case PITCH_D:
-       return "D";
-    case PITCH_Ds:
-       return "D♯";
-    case PITCH_Dss:
-       return "D𝄪";
-    case PITCH_Eff:
-       return "E𝄫";
-    case PITCH_Ef:
-       return "E♭";
-    case PITCH_E:
-       return "E";
-    case PITCH_Es:
-       return "E♯";
-    case PITCH_Ess:
-       return "E𝄪";
-    case PITCH_Fff:
-       return "F𝄫";
-    case PITCH_Ff:
-       return "F♭";
-    case PITCH_F:
-       return "F";
-    case PITCH_Fs:
-       return "F♯";
-    case PITCH_Fss:
-       return "F𝄪";
-    case PITCH_Gff:
-       return "G𝄫";
-    case PITCH_Gf:
-       return "G♭";
-    case PITCH_G:
-       return "G";
-    case PITCH_Gs:
-       return "G♯";
-    case PITCH_Gss:
-       return "G𝄪";
-    case PITCH_Aff:
-       return "A𝄫";
-    case PITCH_Af:
-       return "A♭";
-    case PITCH_A:
-       return "A";
-    case PITCH_As:
-       return "A♯";
-    case PITCH_Ass:
-       return "A𝄪";
-    case PITCH_Bff:
-       return "B𝄫";
-    case PITCH_Bf:
-       return "B♭";
-    case PITCH_B:
-       return "B";
-    case PITCH_Bs:
-       return "B♯";
-    case PITCH_Bss:
-       return "B𝄪";
+    static char double_flat[] = "X𝄫";
+    static char flat[] = "X♭";
+    static char natural[] = "X";
+    static char sharp[] = "X♯";
+    static char double_sharp[] = "X𝄪";
+    char *ret;
+
+    switch (PITCH_ACCIDENTAL (pitch)) {
+    case PITCH_ACCIDENTAL_DOUBLE_FLAT:
+       ret = double_flat;
+       break;
+    case PITCH_ACCIDENTAL_FLAT:
+       ret = flat;
+       break;
+    case PITCH_ACCIDENTAL_NATURAL:
+       ret = natural;
+       break;
+    case PITCH_ACCIDENTAL_SHARP:
+       ret = sharp;
+       break;
+    case PITCH_ACCIDENTAL_DOUBLE_SHARP:
+       ret = double_sharp;
+       break;
+    }
+
+    switch (PITCH_NAME(pitch)) {
+    case PITCH_NAME_C:
+       ret[0] = 'C';
+       break;
+    case PITCH_NAME_D:
+       ret[0] = 'D';
+       break;
+    case PITCH_NAME_E:
+       ret[0] = 'E';
+       break;
+    case PITCH_NAME_F:
+       ret[0] = 'F';
+       break;
+    case PITCH_NAME_G:
+       ret[0] = 'G';
+       break;
+    case PITCH_NAME_A:
+       ret[0] = 'A';
+       break;
+    case PITCH_NAME_B:
+       ret[0] = 'B';
+       break;
     }
 
-    fprintf (stderr, "Internal error: Unknown pitch %d\n", pitch);
-    exit (1);
+    return ret;
 }
 
 typedef struct chord_signature
@@ -1235,25 +1210,25 @@ _select_challenge (scherzo_t *scherzo)
 
     switch (*s) {
     case 'C':
-       pitch = PITCH_C;
+       pitch = PITCH_NATURAL (C);
        break;
     case 'D':
-       pitch = PITCH_D;
+       pitch = PITCH_NATURAL (D);
        break;
     case 'E':
-       pitch = PITCH_E;
+       pitch = PITCH_NATURAL (E);
        break;
     case 'F':
-       pitch = PITCH_F;
+       pitch = PITCH_NATURAL (F);
        break;
     case 'G':
-       pitch = PITCH_G;
+       pitch = PITCH_NATURAL (G);
        break;
     case 'A':
-       pitch = PITCH_A;
+       pitch = PITCH_NATURAL (A);
        break;
     case 'B':
-       pitch = PITCH_B;
+       pitch = PITCH_NATURAL (B);
        break;
     default:
        fprintf (stderr, "Malformed pitch name: %s (expected 'A' - 'G')\n", s);