FreeCalypso > hg > freecalypso-tools

comparison ringtools/imy/convert.c @ 887:3e398f9c31a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fc-imy2pwt: overhaul melody error handling, report position
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 03 Apr 2022 04:17:08 +0000
parents fd4c9bc7835d
children
comparison
equal deleted inserted replaced
886:0d6814238109 887:3e398f9c31a0
17 17
18 static char *pwt_note_names[12] = {"c", "cs", "d", "ds", "e", "f", "fs", 18 static char *pwt_note_names[12] = {"c", "cs", "d", "ds", "e", "f", "fs",
19 "g", "gs", "a", "as", "b"}; 19 "g", "gs", "a", "as", "b"};
20 20
21 static void 21 static void
22 process_octave_cmd(octchar) 22 melody_error(cp, msg)
23 { 23 char *cp, *msg;
24 if (!isdigit(octchar)) { 24 {
25 fprintf(stderr, 25 unsigned pos;
26 "melody error: '*' octave prefix not followed by digit\n"); 26
27 exit(1); 27 pos = cp - melody_str_buf;
28 } 28 fprintf(stderr, "melody error at offset %u: %s\n", pos, msg);
29 cur_octave = octchar - '0'; 29 exit(1);
30 }
31
32 static void
33 process_octave_cmd(cp)
34 char *cp;
35 {
36 if (!isdigit(cp[1]))
37 melody_error(cp, "'*' octave prefix not followed by digit");
38 cur_octave = cp[1] - '0';
30 } 39 }
31 40
32 static int 41 static int
33 process_note(str, type) 42 process_note(str, type)
34 char *str; 43 char *str;
56 break; 65 break;
57 case 'b': 66 case 'b':
58 note = 11; 67 note = 11;
59 break; 68 break;
60 default: 69 default:
61 fprintf(stderr, 70 melody_error(str, "note letter expected after '&' or '#'");
62 "melody error: note letter expected after '&' or '#'\n");
63 exit(1);
64 } 71 }
65 switch (type) { 72 switch (type) {
66 case 1: 73 case 1:
67 if (note == 0 || note == 5) { 74 if (note == 0 || note == 5)
68 fprintf(stderr, "melody error: invalid flat note\n"); 75 melody_error(str, "invalid flat note");
69 exit(1);
70 }
71 note--; 76 note--;
72 break; 77 break;
73 case 2: 78 case 2:
74 if (note == 4 || note == 11) { 79 if (note == 4 || note == 11)
75 fprintf(stderr, "melody error: invalid sharp note\n"); 80 melody_error(str, "invalid sharp note");
76 exit(1);
77 }
78 note++; 81 note++;
79 break; 82 break;
80 } 83 }
81 if (str[1] < '0' || str[1] > '5') { 84 if (str[1] < '0' || str[1] > '5')
82 fprintf(stderr, 85 melody_error(str, "missing expected note duration digit");
83 "melody error: missing expected note duration digit\n");
84 exit(1);
85 }
86 dur_basic = str[1] - '0'; 86 dur_basic = str[1] - '0';
87 switch (str[2]) { 87 switch (str[2]) {
88 case '.': 88 case '.':
89 dur_mod = 1; 89 dur_mod = 1;
90 break; 90 break;
110 process_rest(str) 110 process_rest(str)
111 char *str; 111 char *str;
112 { 112 {
113 int dur_basic, dur_mod; 113 int dur_basic, dur_mod;
114 114
115 if (str[1] < '0' || str[1] > '5') { 115 if (str[1] < '0' || str[1] > '5')
116 fprintf(stderr, 116 melody_error(str, "missing expected rest duration digit");
117 "melody error: missing expected rest duration digit\n");
118 exit(1);
119 }
120 dur_basic = str[1] - '0'; 117 dur_basic = str[1] - '0';
121 switch (str[2]) { 118 switch (str[2]) {
122 case '.': 119 case '.':
123 dur_mod = 1; 120 dur_mod = 1;
124 break; 121 break;
172 continue; 169 continue;
173 } 170 }
174 /* real stuff */ 171 /* real stuff */
175 switch (*cp) { 172 switch (*cp) {
176 case '*': 173 case '*':
177 process_octave_cmd(cp[1]); 174 process_octave_cmd(cp);
178 cp += 2; 175 cp += 2;
179 continue; 176 continue;
180 case 'c': 177 case 'c':
181 case 'd': 178 case 'd':
182 case 'e': 179 case 'e':
202 cp++; 199 cp++;
203 if (*cp == '+' || *cp == '-') { 200 if (*cp == '+' || *cp == '-') {
204 cp++; 201 cp++;
205 continue; 202 continue;
206 } 203 }
207 if (!isdigit(*cp)) { 204 if (!isdigit(*cp))
208 fprintf(stderr, 205 melody_error(cp, "invalid character after 'V'");
209 "melody error: invalid character after 'V'\n");
210 exit(1);
211 }
212 if (*cp == '1' && cp[1] >= '0' && cp[1] <= '5') 206 if (*cp == '1' && cp[1] >= '0' && cp[1] <= '5')
213 cp += 2; 207 cp += 2;
214 else 208 else
215 cp++; 209 cp++;
216 continue; 210 continue;
217 case '(': 211 case '(':
218 if (repeat_start_ptr) { 212 if (repeat_start_ptr)
219 fprintf(stderr, 213 melody_error(cp, "nested repeat");
220 "melody error: nested repeat\n");
221 exit(1);
222 }
223 cp++; 214 cp++;
224 repeat_start_ptr = cp; 215 repeat_start_ptr = cp;
225 repeat_start_octave = cur_octave; 216 repeat_start_octave = cur_octave;
226 repeat_count = 0; 217 repeat_count = 0;
227 continue; 218 continue;
228 case '@': 219 case '@':
229 if (!repeat_start_ptr) { 220 if (!repeat_start_ptr)
230 fprintf(stderr, 221 melody_error(cp, "'@' not in repeat block");
231 "melody error: '@' not in repeat block\n"); 222 cp++;
232 exit(1); 223 if (!isdigit(*cp))
233 } 224 melody_error(cp, "'@' not followed by digit");
234 cp++;
235 if (!isdigit(*cp)) {
236 fprintf(stderr,
237 "melody error: '@' not followed by digit\n");
238 exit(1);
239 }
240 rpt_set = *cp - '0'; 225 rpt_set = *cp - '0';
241 if (!rpt_set) { 226 if (!rpt_set)
242 fprintf(stderr, 227 melody_error(cp,
243 "melody error: infinite repeat not supported\n"); 228 "infinite repeat not supported");
244 exit(1);
245 }
246 cp++; 229 cp++;
247 if (!repeat_count) 230 if (!repeat_count)
248 repeat_count = rpt_set; 231 repeat_count = rpt_set;
249 continue; 232 continue;
250 case ')': 233 case ')':
251 if (!repeat_start_ptr) { 234 if (!repeat_start_ptr)
252 fprintf(stderr, 235 melody_error(cp, "')' without opening '('");
253 "melody error: ')' without opening '('\n"); 236 if (!repeat_count)
254 exit(1); 237 melody_error(cp, "repeat block without count");
255 }
256 if (!repeat_count) {
257 fprintf(stderr,
258 "melody error: repeat block without count\n");
259 exit(1);
260 }
261 repeat_count--; 238 repeat_count--;
262 if (repeat_count) { 239 if (repeat_count) {
263 cp = repeat_start_ptr; 240 cp = repeat_start_ptr;
264 cur_octave = repeat_start_octave; 241 cur_octave = repeat_start_octave;
265 } else { 242 } else {
266 cp++; 243 cp++;
267 repeat_start_ptr = 0; 244 repeat_start_ptr = 0;
268 } 245 }
269 continue; 246 continue;
270 default: 247 default:
271 fprintf(stderr, 248 melody_error(cp, "non-understood character");
272 "melody error: non-understood character\n"); 249 }
273 exit(1); 250 }
274 } 251 }
275 }
276 }