?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
When doubling the page size, the new page size is never bigger
[ahxm.git] / compiler.y
blobaa7fffd35d7251270f480a83595cd22d54224785
1 %{
2 /*
3
4 Ann Hell Ex Machina - Music Software
5 Copyright (C) 2003/2006 Angel Ortega <angel@triptico.com>
6
7 compiler.y - Scripting language YACC parser
8
9 This program is free software; you can redistribute it and/or
10 modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2
12 of the License, or (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22
23 http://www.triptico.com
24
25 */
26
27 #include "config.h"
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <math.h>
33
34 #include "ahxm.h"
35
36 /*******************
37 Data
38 ********************/
39
40 int yylex(void);
41 void yyerror(char * s);
42
43 /* injecting code functions (defined in compiler.l) */
44 int push_code(char * code);
45 int push_code_from_file(char * file);
46
47 /* current track */
48 int track;
49
50 /* current time */
51 double cur_time;
52
53 /* note globals */
54 static double length;
55 static int octave;
56 static int transpose;
57 static double staccato;
58 static float volume;
59 static double gliss;
60
61 /* parser debugging */
62
63 #define DEBUGF if(verbose >= 2)printf
64
65 /* blocks */
66
67 struct block
68 {
69 char * name;
70 int n_sblocks;
71 char ** sblocks;
72 };
73
74 static struct block * blocks = NULL;
75 static int n_blocks = 0;
76
77 /* group info */
78 struct group
79 {
80 double start;
81 double gliss;
82 double max;
83 };
84
85 static struct group * groups = NULL;
86 static int n_groups = 0;
87 static int groups_size = 0;
88
89 /* mark info */
90 struct mark
91 {
92 char * name;
93 double time;
94 };
95
96 static struct mark * marks = NULL;
97 static int n_marks = 0;
98
99 /* arpeggiator */
100 struct arp
101 {
102 double delay;
103 int transpose;
104 float volume;
105 int track_off;
106 };
107
108 static struct arp * arps = NULL;
109 static int n_arps = 0;
110 static int arps_size = 0;
111
112 static double arp_delay;
113 static int arp_transpose;
114 static float arp_volume;
115 static int arp_track_off;
116
117 int compiler_error = 0;
118
119 extern int yyline;
120
121 #ifdef TONALITIES
122 int tonality = 0; /* C Major */
123
124 int tonalities[12][12] = {
125 /* C C# D D# E F F# G G# A A# B */
126 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* CM / Am */
127 { 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1 }, /* C#M / A#m */
128 { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, /* DM / Bm */
129 { 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, -1 }, /* E&M / Cm */
130 { 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 }, /* EM / C#m */
131 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 }, /* FM / Dm */
132 { 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0 }, /* F#M / D#m */
133 { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, /* GM / Em */
134 { 0, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, -1 }, /* A&M / Fm */
135 { 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0 }, /* AM / F#m */
136 { 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1 }, /* B&M / Gm */
137 { 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0 } /* BM / G#m */
138 };
139 #endif /* TONALITIES */
140
141 /* alterations for each note */
142 int alterations[12];
143
144 /* random seeds */
145 unsigned long block_seed = 0;
146
147 /*******************
148 Code
149 ********************/
150
151 unsigned long ah_rnd(unsigned long * seed)
152 /* special randomizer */
153 {
154 *seed = (*seed * 58321) + 11113;
155
156 return(*seed >> 16);
157 }
158
159
160 void c_err(char * e1, char * e2, char * e3)
161 /* reports an error from the compiler */
162 {
163 printf("ahxm:");
164 if(e1 != NULL) printf(" %s", e1);
165 if(e2 != NULL) printf(" %s", e2);
166 if(e3 != NULL) printf(" %s", e3);
167 printf(" in line %d\n", yyline);
168
169 compiler_error++;
170 }
171
172
173 static void forward(double step)
174 /* moves forward current time */
175 {
176 /* add step */
177 cur_time += step;
178
179 /* quantizations could be done here */
180 }
181
182
183 /* blocks */
184
185 static int find_block(char * name)
186 /* finds a block */
187 {
188 int n;
189
190 for(n = 0;n < n_blocks;n++)
191 {
192 if(strcmp(name, blocks[n].name) == 0)
193 return(n);
194 }
195
196 return(-1);
197 }
198
199
200 static int set_block(char * name, char * block)
201 /* defines a block */
202 {
203 int n;
204 struct block * b;
205 char * start;
206 char * stop;
207
208 /* if block already exists, free it */
209 if((n = find_block(name)) >= 0)
210 {
211 b = &blocks[n];
212
213 /* free all subblocks */
214 for(n = 0;n < b->n_sblocks;n++)
215 free(b->sblocks[n]);
216
217 /* free the subblock array */
218 free(b->sblocks);
219 }
220 else
221 {
222 GROW(blocks, n_blocks, struct block);
223 b = &blocks[n_blocks++];
224
225 b->name = strdup(name);
226 }
227
228 /* reset */
229 b->n_sblocks = 0;
230 b->sblocks = NULL;
231
232 /* now split in subblocks (delimited by : ) */
233 start = block;
234
235 while((stop = strchr(start, ':')) != NULL)
236 {
237 /* break there */
238 *stop = '\0';
239
240 /* add the subblock */
241 GROW(b->sblocks, b->n_sblocks, char *);
242 b->sblocks[b->n_sblocks++] = strdup(start);
243
244 start = stop + 1;
245 }
246
247 /* no more separators? store the rest */
248 GROW(b->sblocks, b->n_sblocks, char *);
249 b->sblocks[b->n_sblocks++] = strdup(start);
250
251 /* the original block is no longer needed */
252 free(block);
253
254 return(1);
255 }
256
257
258 static void insert_block(char * name)
259 /* inserts a block */
260 {
261 int n;
262
263 if((n = find_block(name)) >= 0)
264 {
265 struct block * b;
266
267 b = &blocks[n];
268
269 /* get one of them, randomly */
270 n = ah_rnd(&block_seed) % b->n_sblocks;
271
272 push_code(strdup(b->sblocks[n]));
273 }
274 else
275 c_err("block-not-found", name, NULL);
276 }
277
278
279 static int insert_file(char * filename)
280 {
281 if(!push_code_from_file(filename))
282 {
283 c_err("script-not-found", filename, NULL);
284 return(1);
285 }
286
287 return(0);
288 }
289
290
291 /* groups */
292
293 static int push_group(void)
294 /* starts a new group of notes */
295 {
296 struct group * g;
297
298 if(n_groups == groups_size)
299 {
300 GROW(groups, groups_size, struct group);
301 groups_size ++;
302 }
303
304 g = &groups[n_groups++];
305
306 g->start = cur_time;
307 g->gliss = 0.0;
308 g->max = 0.0;
309
310 return(1);
311 }
312
313
314 static int next_group_part(void)
315 /* part delimiter */
316 {
317 struct group * g;
318
319 if(n_groups == 0)
320 {
321 c_err("missing-start-of-group", NULL, NULL);
322 return(0);
323 }
324
325 g = &groups[n_groups - 1];
326
327 /* store maximum frame */
328 if(g->max < cur_time)
329 g->max = cur_time;
330
331 /* add glissando delay */
332 g->gliss += gliss;
333
334 /* rewind */
335 cur_time = g->start + g->gliss;
336
337 return(1);
338 }
339
340
341 static int pop_group(void)
342 /* finishes a group, moving the frame to the end of the longer part */
343 {
344 if(n_groups == 0)
345 {
346 c_err("missing-start-of-group", NULL, NULL);
347 return(0);
348 }
349
350 n_groups--;
351
352 /* if other parts of group were longer than the last one,
353 move pointer there */
354 if(groups[n_groups].max > cur_time)
355 cur_time = groups[n_groups].max;
356
357 return(1);
358 }
359
360
361 /* marks */
362
363 static void add_mark(char * name)
364 /* creates a new mark */
365 {
366 GROW(marks, n_marks, struct mark);
367
368 marks[n_marks].name = strdup(name);
369 marks[n_marks].time = cur_time;
370
371 n_marks++;
372 }
373
374
375 static void find_mark(char * name, int set)
376 /* finds a mark by name, optionally moving time cursor there */
377 {
378 int n;
379
380 for(n = 0;n < n_marks;n++)
381 {
382 if(strcmp(marks[n].name, name) == 0)
383 {
384 if(set)
385 {
386 if(cur_time > marks[n].time)
387 c_err("mark-overpassed", name, NULL);
388 else
389 cur_time = marks[n].time;
390 }
391 else
392 if(cur_time != marks[n].time)
393 c_err("mark-mismatch", name, NULL);
394
395 return;
396 }
397 }
398
399 c_err("mark-not-found", name, NULL);
400 }
401
402
403 /* arpeggiator */
404
405 static void arp_default(void)
406 /* resets arpeggiator values to the default ones */
407 {
408 arp_delay = 0.0;
409 arp_transpose = 0;
410 arp_volume = 1.0;
411 arp_track_off = 0;
412 }
413
414
415 static void add_arp(void)
416 /* adds an arpeggiator note */
417 {
418 struct arp * a;
419
420 /* if the note is exactly the same, do nothing */
421 if(arp_delay == 0.0 && arp_transpose == 0 &&
422 arp_volume == 1.0 && arp_track_off == 0)
423 return;
424
425 if(n_arps == arps_size)
426 {
427 GROW(arps, arps_size, struct arp);
428 arps_size ++;
429 }
430
431 a = &arps[n_arps];
432
433 a->delay = arp_delay;
434 a->transpose = arp_transpose;
435 a->volume = arp_volume;
436 a->track_off = arp_track_off;
437
438 n_arps++;
439 arp_default();
440 }
441
442
443 static void set_alteration(char * altstr)
444 /* sets the alterations from altstr */
445 {
446 int n, steps[] = { 2, 0, 2, 0, 1, 2, 0, 2, 0, 2, 0, 1 };
447
448 /* reset alterations */
449 for(n = 0;n < 12;n++) alterations[n] = 0;
450
451 /* changed according the altstr spec */
452 for(n = 0;*altstr != '\0' && n < 12;altstr++)
453 {
454 switch(*altstr)
455 {
456 case '&': alterations[n] = -1; break;
457 case '#': alterations[n] = 1; break;
458 }
459
460 /* move to next natural note */
461 n += steps[n];
462 }
463 }
464
465
466 /* song events */
467
468 static void add_note_event(int note)
469 /* adds a note event */
470 {
471 int n;
472 int np;
473 union song_ev e;
474
475 /* sum the tonality alteration */
476 /* note += tonalities[tonality][((unsigned) note) % 12];*/
477
478 /* sum the alteration */
479 note += alterations[((unsigned) note) % 12];
480
481 /* calculate the note */
482 np = note + transpose + (octave * 12);
483
484 /* is note out of range? */
485 if(np < 0 || np > 127)
486 {
487 c_err("note-out-of-range", NULL, NULL);
488 return;
489 }
490
491 e.note.trk_id = track;
492 e.note.note = np;
493 e.note.len = length * staccato;
494 e.note.vol = volume;
495
496 add_song_ev(SONG_EV_NOTE, cur_time, &e);
497
498 /* add arpeggiator repetitions */
499 for(n = 0;n < n_arps;n++)
500 {
501 e.note.trk_id = track + arps[n].track_off;
502 e.note.note = np + arps[n].transpose;
503 e.note.vol = volume * arps[n].volume;
504
505 add_song_ev(SONG_EV_NOTE, cur_time + arps[n].delay, &e);
506 }
507 }
508
509
510 static void add_back_event(void)
511 {
512 union song_ev e;
513
514 e.back.trk_id = track;
515 e.back.len = length;
516 add_song_ev(SONG_EV_BACK, cur_time, &e);
517 }
518
519
520 static void add_tempo_event(int trk_id, double tempo)
521 {
522 union song_ev e;
523
524 e.tempo.trk_id = trk_id;
525 e.tempo.tempo = tempo;
526 add_song_ev(SONG_EV_TEMPO, cur_time, &e);
527 }
528
529
530 static void add_meter_event(int trk_id, int num, int den)
531 {
532 union song_ev e;
533
534 e.meter.trk_id = trk_id;
535 e.meter.num = num;
536 e.meter.den = den;
537 add_song_ev(SONG_EV_METER, cur_time, &e);
538 }
539
540 static void add_measure_event(void)
541 {
542 union song_ev e;
543
544 e.measure.trk_id = -1;
545 e.measure.line = yyline;
546
547 add_song_ev(SONG_EV_MEASURE, cur_time, &e);
548 }
549
550
551 static void add_ss_sustain_event(double sustain)
552 {
553 union song_ev e;
554
555 e.ss_sustain.trk_id = track;
556 e.ss_sustain.sustain = sustain;
557
558 add_song_ev(SONG_EV_SS_SUSTAIN, cur_time, &e);
559 }
560
561
562 static void add_ss_vibrato_event(double depth, double freq)
563 {
564 union song_ev e;
565
566 e.ss_vibrato.trk_id = track;
567 e.ss_vibrato.vib_depth = depth;
568 e.ss_vibrato.vib_freq = freq;
569
570 add_song_ev(SONG_EV_SS_VIBRATO, cur_time, &e);
571 }
572
573
574 static void add_ss_portamento_event(double portamento)
575 {
576 union song_ev e;
577
578 e.ss_portamento.trk_id = track;
579 e.ss_portamento.portamento = portamento;
580
581 add_song_ev(SONG_EV_SS_PORTAMENTO, cur_time, &e);
582 }
583
584
585 static void add_ss_channel_event(int channel, float vol)
586 {
587 union song_ev e;
588
589 e.ss_channel.trk_id = track;
590 e.ss_channel.channel = channel;
591 e.ss_channel.vol = vol;
592
593 add_song_ev(SONG_EV_SS_CHANNEL, cur_time, &e);
594 }
595
596
597 static void add_ss_wav_event(char * wav_file, int base, int min, int max,
598 double loop_start, double loop_end, int first_channel, int skip_channels)
599 {
600 union song_ev e;
601
602 e.ss_wav.trk_id = track;
603 e.ss_wav.file = wav_file;
604 e.ss_wav.base = base;
605 e.ss_wav.min = min;
606 e.ss_wav.max = max;
607 e.ss_wav.loop_start = loop_start;
608 e.ss_wav.loop_end = loop_end;
609 e.ss_wav.first_channel = first_channel;
610 e.ss_wav.skip_channels = skip_channels;
611
612 add_song_ev(SONG_EV_SS_WAV, cur_time, &e);
613 }
614
615
616 static void add_ss_pat_event(char * pat_file)
617 {
618 union song_ev e;
619
620 e.ss_pat.trk_id = track;
621 e.ss_pat.file = pat_file;
622
623 add_song_ev(SONG_EV_SS_PAT, cur_time, &e);
624 }
625
626
627 static void add_ss_eff_event(int type, int channel, double size, float gain,
628 double depth, double freq, double phase, float initial, float final)
629 {
630 union song_ev e;
631
632 e.ss_eff.trk_id = track;
633 e.ss_eff.channel = channel;
634 e.ss_eff.size = size;
635 e.ss_eff.gain = gain;
636 e.ss_eff.depth = depth;
637 e.ss_eff.freq = freq;
638 e.ss_eff.phase = phase;
639 e.ss_eff.initial = initial;
640 e.ss_eff.final = final;
641
642 add_song_ev(type, cur_time, &e);
643 }
644
645
646 static void add_ss_pitch_stretch(int note, double len, float vol)
647 {
648 union song_ev e;
649
650 e.ss_pitch_stretch.trk_id = track;
651 e.ss_pitch_stretch.note = note;
652 e.ss_pitch_stretch.len = len;
653 e.ss_pitch_stretch.vol = vol;
654
655 add_song_ev(SONG_EV_SS_PITCH_STRETCH, cur_time, &e);
656 }
657
658
659 static void add_ss_print_wave_tempo(int note, double len)
660 {
661 union song_ev e;
662
663 e.ss_print_wave_tempo.trk_id = track;
664 e.ss_print_wave_tempo.note = note;
665 e.ss_print_wave_tempo.len = len;
666
667 add_song_ev(SONG_EV_SS_PRINT_WAVE_TEMPO, cur_time, &e);
668 }
669
670
671 static void add_midi_channel_event(int channel)
672 {
673 union song_ev e;
674
675 e.midi_channel.trk_id = track;
676 e.midi_channel.channel = channel - 1;
677
678 add_song_ev(SONG_EV_MIDI_CHANNEL, cur_time, &e);
679 }
680
681
682 static void add_midi_program_event(int program)
683 {
684 union song_ev e;
685
686 e.midi_program.trk_id = track;
687 e.midi_program.program = program;
688
689 add_song_ev(SONG_EV_MIDI_PROGRAM, cur_time, &e);
690 }
691
692
693 static void add_song_info_event(char * author, char * name)
694 {
695 union song_ev e;
696
697 e.song_info.trk_id = track;
698 e.song_info.author = author;
699 e.song_info.name = name;
700
701 add_song_ev(SONG_EV_SONG_INFO, cur_time, &e);
702 }
703
704
705 static void init_track(void)
706 /* sets the default values for a new track */
707 {
708 int n;
709
710 cur_time = 0.0;
711 length = 0.0;
712 transpose = 0;
713 staccato = 0.8;
714 volume = 0.75;
715 octave = 5;
716 gliss = 0;
717
718 /* groups should not cross track boundaries */
719 n_groups = 0;
720
721 /* reset arpeggiator */
722 n_arps = 0;
723 arp_default();
724
725 /* reset alterations */
726 for(n = 0;n < 12;n++)
727 alterations[n] = 0;
728 }
729
730
731 %}
732
733 %union {
734 int i;
735 double d;
736 char * p;
737 };
738
739 %token <i> P_INTEGER S_INTEGER
740 %token <d> P_REAL S_REAL
741 %token <i> NOTE_P NOTE_T3 NOTE_T5
742 %token <p> NEW_MARK GOTO_MARK ASSERT_MARK
743
744 %token <p> BLOCK BLK_ASSIGN BLK_INSERT FILE_INSERT
745
746 %token <p> ALTSTR
747
748 %token <p> XC_STR
749 %token <i> XC_ABSNOTE
750 %token <d> XC_MSECS
751
752 %token SS_SEP SS_WAV SS_LOOP_WAV SS_PAT
753 %token SS_SUSTAIN SS_VIBRATO SS_PORTAMENTO SS_CHANNEL SS_VOL
754
755 %token SS_EFF_DELAY SS_EFF_ECHO SS_EFF_COMB SS_EFF_ALLPASS SS_EFF_FLANGER
756 %token SS_EFF_WOBBLE SS_EFF_SQWOBBLE SS_EFF_HFWOBBLE
757 %token SS_EFF_FADER SS_EFF_REVERB SS_EFF_FOLDBACK SS_EFF_OFF
758
759 %token SS_PITCH_STRETCH SS_TIME_STRETCH SS_PRINT_WAVE_TEMPO
760
761 %token SONG_INFO
762
763 %token MIDI_CHANNEL MIDI_PROGRAM MIDI_GENERIC
764
765 %type <i> integer note note_pitch rest back
766 %type <d> real p_number number note_length
767
768 %type <d> arp_list arp_note
769 %type <i> xc_absnote
770
771 %%
772
773 script:
774 script stmt { ; }
775 | /* NULL */
776 ;
777
778 stmt:
779 note {
780 /* note event */
781 add_note_event($1);
782 forward(length);
783 }
784 | rest {
785 /* rest */
786 forward(length);
787 }
788 | back {
789 /* back */
790 add_back_event();
791 }
792 | 'z' note_length {
793 /* zero note */
794 length = $2;
795 }
796 | 'o' P_INTEGER {
797 /* absolute octave */
798 octave = $2;
799 }
800 | 'o' S_INTEGER {
801 /* relative octave */
802 octave += $2;
803 }
804 | 'v' P_INTEGER {
805 /* absolute volume */
806 volume = (float)$2;
807 }
808 | 'v' P_REAL {
809 /* absolute volume */
810 volume = (float)$2;
811 }
812 | 'v' S_REAL {
813 /* relative volume */
814 volume += (float)$2;
815 }
816 | 't' integer {
817 /* transpose */
818 transpose = $2;
819 }
820 | 's' p_number {
821 /* staccato */
822 staccato = $2;
823 }
824
825 | '<' {
826 /* start of group */
827 push_group();
828 }
829 | ';' {
830 /* group delimiter */
831 next_group_part();
832 }
833 | '>' {
834 /* end of group */
835 pop_group();
836 }
837 | 'l' note_length {
838 /* glissando */
839 gliss = $2;
840 }
841
842 | '|' {
843 /* measure mark event */
844 add_measure_event();
845 }
846
847 | NEW_MARK {
848 /* add new mark */
849 add_mark($1);
850 }
851 | GOTO_MARK {
852 /* go to mark */
853 find_mark($1, 1);
854 }
855 | ASSERT_MARK {
856 /* assert mark */
857 find_mark($1, 0);
858 }
859
860 | '\\' {
861 /* new track */
862
863 track++;
864 init_track();
865 }
866 | 'T' p_number {
867 /* tempo setting */
868 add_tempo_event(-1, $2);
869 }
870 | 'M' P_INTEGER '/' P_INTEGER {
871 /* meter (time signature) setting */
872 add_meter_event(-1, $2, $4);
873 }
874 | ALTSTR {
875 /* alteration string */
876 set_alteration($1);
877 }
878
879 | BLOCK '*' P_INTEGER {
880 /* repeat block */
881 int n;
882
883 /* store the block as <TMP> */
884 set_block("<TMP>", $1);
885
886 for(n = 0;n < $3;n++)
887 insert_block("<TMP>");
888 }
889 | BLOCK BLK_ASSIGN {
890 /* assign block */
891 set_block($2, $1);
892 }
893 | BLK_INSERT {
894 /* insert block */
895 insert_block($1);
896 }
897 | FILE_INSERT {
898 /* insert file */
899 insert_file($1);
900 }
901
902 | arp { ; }
903
904 | xc_cmd { ; }
905
906 ;
907
908 integer:
909 P_INTEGER { $$ = $1; }
910 | S_INTEGER { $$ = $1; }
911 ;
912
913 real:
914 P_REAL { $$ = $1; }
915 | S_REAL { $$ = $1; }
916 ;
917
918 p_number:
919 P_INTEGER { $$ = (double) $1; }
920 | P_REAL { $$ = $1; }
921 ;
922
923 number:
924 integer { $$ = (double) $1; }
925 | real { $$ = $1; }
926 ;
927
928 note:
929 note_pitch { $$ = $1; }
930 | note note_length { $$ = $1; length=$2; }
931 | note '~' number { $$ = $1; DEBUGF("imm volume: %lf\n", $3); }
932 ;
933
934 note_pitch:
935 NOTE_P { $$ = $1; }
936 | note_pitch '&' { $$ = $1 - 1; }
937 | note_pitch '#' { $$ = $1 + 1; }
938 | note_pitch '\'' { $$ = $1 + 12; }
939 | note_pitch ',' { $$ = $1 - 12; }
940 ;
941
942 note_length:
943 P_INTEGER { $$ = 1 / (double) $1; }
944 | note_length NOTE_T3 { $$ = $1 * 2.0 / 3.0; }
945 | note_length NOTE_T5 { $$ = $1 * 4.0 / 5.0; }
946 | note_length '*' p_number { $$ = $1 * $3; }
947 | note_length '.' { $$ = $1 * 1.5; }
948 ;
949
950 rest:
951 'r' { ; }
952 | rest note_length {
953 /* rest with length */
954 length = $2;
955 }
956 ;
957
958 back:
959 'k' { ; }
960 | back note_length {
961 /* back with length */
962 length = $2;
963 }
964 ;
965
966 arp:
967 'x' {
968 /* empty arpeggiator */
969 n_arps = 0;
970 arp_default();
971 }
972 | 'x' arp_list { ; }
973 ;
974
975 arp_list:
976 arp_note {
977 /* first arpeggiator note */
978 n_arps = 0;
979 add_arp();
980 }
981 | arp_list ',' arp_note {
982 /* rest of arpeggiator notes */
983 add_arp();
984 }
985 ;
986
987 arp_note:
988 note_length {
989 /* arpeggiator delay */
990 arp_delay = $1;
991 }
992 | arp_note '~' number {
993 /* arpeggiator volume */
994 arp_volume = (float)$3;
995 }
996 | arp_note S_INTEGER {
997 /* arpeggiator transpose */
998 arp_transpose = $2;
999 }
1000 | arp_note '/' P_INTEGER {
1001 /* arpeggiator track offset */
1002 arp_track_off = $3;
1003 }
1004 | arp_note NOTE_T3 {
1005 /* HACK: /3 */
1006 arp_track_off = 3;
1007 }
1008 | arp_note NOTE_T5 {
1009 /* HACK: /5 */
1010 arp_track_off = 5;
1011 }
1012 ;
1013
1014 xc_absnote:
1015 P_INTEGER { $$ = $1; }
1016 | XC_ABSNOTE { $$ = $1; }
1017 ;
1018
1019 xc_cmd:
1020 SS_WAV XC_STR xc_absnote {
1021 /* load .wav file with just one note */
1022 add_ss_wav_event($2, $3, $3, $3, -1.0, -1.0, 0, 0);
1023 }
1024 | SS_WAV XC_STR xc_absnote xc_absnote xc_absnote {
1025 /* load .wav file */
1026 add_ss_wav_event($2, $3, $4, $5, -1.0, -1.0, 0, 0);
1027 }
1028 | SS_WAV XC_STR xc_absnote xc_absnote xc_absnote number number {
1029 /* load .wav file, with loop boundaries */
1030 add_ss_wav_event($2, $3, $4, $5, $6, $7, 0, 0);
1031 }
1032 | SS_WAV XC_STR xc_absnote xc_absnote xc_absnote number number number number {
1033 /* load .wav file, with loop boundaries,
1034 first channel and skip channels */
1035 add_ss_wav_event($2, $3, $4, $5, $6, $7, $8, $9);
1036 }
1037 | SS_PAT XC_STR {
1038 /* load .pat file */
1039 add_ss_pat_event($2);
1040 }
1041 | SS_SUSTAIN XC_MSECS {
1042 /* sets sustain */
1043 add_ss_sustain_event($2);
1044 }
1045 | SS_VIBRATO XC_MSECS number {
1046 /* sets vibrato */
1047 add_ss_vibrato_event($2, $3);
1048 }
1049 | SS_PORTAMENTO number {
1050 /* sets portamento */
1051 add_ss_portamento_event($2);
1052 }
1053 | SS_CHANNEL integer number {
1054 /* sets volume for a channel */
1055 add_ss_channel_event($2, $3);
1056 }
1057 | SS_VOL number number {
1058 /* set vol for 2 channels */
1059 add_ss_channel_event(0, $2);
1060 add_ss_channel_event(1, $3);
1061 }
1062 | SS_VOL number number number {
1063 /* set vol for 3 channels */
1064 add_ss_channel_event(0, $2);
1065 add_ss_channel_event(1, $3);
1066 add_ss_channel_event(2, $4);
1067 }
1068 | SS_VOL number number number number {
1069 /* set vol for 4 channels */
1070 add_ss_channel_event(0, $2);
1071 add_ss_channel_event(1, $3);
1072 add_ss_channel_event(2, $4);
1073 add_ss_channel_event(3, $5);
1074 }
1075 | SS_VOL number number number number number number {
1076 /* set vol for 6 channels */
1077 add_ss_channel_event(0, $2);
1078 add_ss_channel_event(1, $3);
1079 add_ss_channel_event(2, $4);
1080 add_ss_channel_event(3, $5);
1081 add_ss_channel_event(4, $6);
1082 add_ss_channel_event(5, $7);
1083 }
1084 | SS_EFF_DELAY integer XC_MSECS {
1085 /* delay effect */
1086 add_ss_eff_event(SONG_EV_SS_EFF_DELAY,
1087 $2, $3, 0, 0, 0, 0, 0, 0);
1088 }
1089
1090 | SS_EFF_ECHO integer XC_MSECS number {
1091 /* echo effect */
1092 add_ss_eff_event(SONG_EV_SS_EFF_ECHO,
1093 $2, $3, $4, 0, 0, 0, 0, 0);
1094 }
1095
1096 | SS_EFF_COMB integer XC_MSECS number {
1097 /* comb effect */
1098 add_ss_eff_event(SONG_EV_SS_EFF_COMB,
1099 $2, $3, $4, 0, 0, 0, 0, 0);
1100 }
1101
1102 | SS_EFF_ALLPASS integer XC_MSECS number {
1103 /* allpass effect */
1104 add_ss_eff_event(SONG_EV_SS_EFF_ALLPASS,
1105 $2, $3, $4, 0, 0, 0, 0, 0);
1106 }
1107
1108 | SS_EFF_FLANGER integer XC_MSECS number XC_MSECS number number {
1109 /* flanger effect */
1110 add_ss_eff_event(SONG_EV_SS_EFF_FLANGER,
1111 $2, $3, $4, $5, $6, $7, 0, 0);
1112 }
1113
1114 | SS_EFF_WOBBLE integer number number {
1115 /* wobble effect */
1116 add_ss_eff_event(SONG_EV_SS_EFF_WOBBLE,
1117 $2, 0, 0, 0, $3, $4, 0, 0);
1118 }
1119
1120 | SS_EFF_SQWOBBLE integer number number {
1121 /* square wobble effect */
1122 add_ss_eff_event(SONG_EV_SS_EFF_SQWOBBLE,
1123 $2, 0, 0, 0, $3, $4, 0, 0);
1124 }
1125
1126 | SS_EFF_HFWOBBLE integer number number {
1127 /* half wobble effect */
1128 add_ss_eff_event(SONG_EV_SS_EFF_HFWOBBLE,
1129 $2, 0, 0, 0, $3, $4, 0, 0);
1130 }
1131
1132 | SS_EFF_FADER integer XC_MSECS number number {
1133 /* fader effect */
1134 add_ss_eff_event(SONG_EV_SS_EFF_FADER,
1135 $2, $3, 0, 0, 0, 0, $4, $5);
1136 }
1137
1138 | SS_EFF_REVERB integer {
1139 /* reverb effect */
1140 add_ss_eff_event(SONG_EV_SS_EFF_REVERB,
1141 $2, 0, 0, 0, 0, 0, 0, 0);
1142 }
1143
1144 | SS_EFF_FOLDBACK integer number {
1145 /* foldback distortion effect */
1146 add_ss_eff_event(SONG_EV_SS_EFF_FOLDBACK,
1147 $2, 0, $3, 0, 0, 0, 0, 0);
1148 }
1149 | SS_EFF_OFF integer {
1150 /* off effect */
1151 add_ss_eff_event(SONG_EV_SS_EFF_OFF,
1152 $2, 0, 0, 0, 0, 0, 0, 0);
1153 }
1154
1155 | SS_PITCH_STRETCH xc_absnote number number {
1156 /* pitch stretch note */
1157 add_ss_pitch_stretch($2, $3, $4);
1158
1159 forward($3);
1160 }
1161
1162 | SS_PRINT_WAVE_TEMPO xc_absnote number {
1163 /* print tempo from wave */
1164 add_ss_print_wave_tempo($2, $3);
1165 }
1166
1167 | SONG_INFO XC_STR XC_STR {
1168 /* add song info */
1169 add_song_info_event($2, $3);
1170 }
1171
1172 | MIDI_CHANNEL integer {
1173 /* midi channel */
1174 add_midi_channel_event($2);
1175 }
1176
1177 | MIDI_PROGRAM integer {
1178 /* midi program */
1179 add_midi_program_event($2);
1180 }
1181 ;
1182
1183 %%
1184
1185 void yyerror(char * s)
1186 {
1187 c_err(s, NULL, NULL);
1188 }
1189
1190
1191 static void compile_startup(void)
1192 {
1193 track = 0;
1194 yyline = 1;
1195 compiler_error = 0;
1196
1197 /* default settings */
1198 add_tempo_event(-2, 120.0);
1199 add_meter_event(-2, 4, 4);
1200 init_track();
1201 }
1202
1203
1204 int compile_ahs_string(char * code)
1205 {
1206 compile_startup();
1207
1208 push_code(strdup(code));
1209
1210 return(yyparse() + compiler_error);
1211 }
1212
1213
1214 int compile_ahs(char * file)
1215 {
1216 compile_startup();
1217
1218 if(insert_file(file))
1219 return(1);
1220
1221 return(yyparse() + compiler_error);
1222 }
Ann Hell Ex Machina (music writing software)