The 'off' directive has been added, to set to off the effect chain

[ahxm.git] / compiler.y

%{
/*

    Ann Hell Ex Machina - Music Software
    Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>

    compiler.y - Scripting language YACC parser

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    http://www.triptico.com

*/

#include "config.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#include "ss_core.h"            /* for ss_debug */
#include "song.h"

/*******************
        Data
********************/

int yylex(void);
void yyerror(char * s);

/* injecting code functions (defined in compiler.l) */
int push_code(char * code, int times, int dyn);
int push_code_from_file(char * file);

/* current track */
int _track;

/* current time */
double _cur_time;

/* note globals */
static double _length;
static int _octave;
static int _transpose;
static double _staccato;
static float _volume;
static double _gliss;

/* parser debugging */

#define DEBUGF if(ss_debug)printf

/* named blocks */

struct _named_block
{
        char name[64];
        char * block;
};

static struct _named_block * _named_blocks=NULL;
static int _n_named_blocks=0;
static int _named_blocks_size=0;

/* group info */
struct _group
{
        double start;
        double gliss;
        double max;
};

static struct _group * _groups=NULL;
static int _n_groups=0;
static int _groups_size=0;

/* mark info */
struct _mark
{
        char name[64];
        double time;
};

static struct _mark * _marks=NULL;
static int _n_marks=0;
static int _marks_size=0;

/* arpeggiator */
struct _arp
{
        double delay;
        int transpose;
        float volume;
        int track;
};

static struct _arp * _arps=NULL;
static int _n_arps=0;
static int _arps_size=0;

static double _arp_delay;
static int _arp_transpose;
static float _arp_volume;
static int _arp_track;

int compiler_error=0;

extern int yyline;

/*******************
        Code
********************/

void _c_err(char * e1, char * e2, char * e3)
/* reports an error from the compiler */
{
        printf("ahxm:");
        if(e1 != NULL) printf(" %s", e1);
        if(e2 != NULL) printf(" %s", e2);
        if(e3 != NULL) printf(" %s", e3);
        printf(" in line %d\n", yyline);

        compiler_error++;
}


static void _forward(void)
/* moves forward current time by current length */
{
        /* just add current length to time cursor */
        _cur_time += _length;

        /* quantizations could be done here */
}


/* named blocks */

static int _set_named_block(char * name, char * block)
/* sets a named block */
{
        int n;

        /* find first if block is previously defined */
        for(n=0;n < _n_named_blocks;n++)
        {
                if(strcmp(name, _named_blocks[n].name) == 0)
                {
                        free(_named_blocks[n].block);
                        break;
                }
        }

        if(n == _n_named_blocks)
        {
                /* need to expand? */
                if(_n_named_blocks == _named_blocks_size)
                {
                        _named_blocks_size += 4;

                        _named_blocks=(struct _named_block *)
                                realloc(_named_blocks,
                                _named_blocks_size *
                                        sizeof(struct _named_block));
                }

                _n_named_blocks++;
        }

        strncpy(_named_blocks[n].name, name, sizeof(_named_blocks[n].name));
        _named_blocks[n].block=block;

        return(1);
}


static void _insert_named_block(char * name)
/* inserts a named block */
{
        int n;

        for(n=0;n < _n_named_blocks;n++)
        {
                if(strcmp(name, _named_blocks[n].name) == 0)
                {
                        push_code(_named_blocks[n].block, 1, 0);
                        return;
                }
        }

        _c_err("block-not-found", name, NULL);
}


static int _insert_file(char * filename)
{
        if(!push_code_from_file(filename))
        {
                _c_err("script-not-found", filename, NULL);
                return(1);
        }

        return(0);
}


/* groups */

static int _push_group(void)
/* starts a new group of notes */
{
        if(_n_groups == _groups_size)
        {
                _groups_size += 4;

                _groups=(struct _group *) realloc(_groups,
                        _groups_size * sizeof(struct _group));
        }

        _groups[_n_groups].start=_cur_time;
        _groups[_n_groups].gliss=0.0;
        _groups[_n_groups].max=0.0;

        _n_groups++;

        return(1);
}


static int _next_group_part(void)
/* part delimiter */
{
        if(_n_groups == 0)
        {
                _c_err("missing-start-of-group", NULL, NULL);
                return(0);
        }

        /* store maximum frame */
        if(_groups[_n_groups - 1].max < _cur_time)
                _groups[_n_groups - 1].max=_cur_time;

        /* add glissando delay */
        _groups[_n_groups - 1].gliss += _gliss;

        /* rewind */
        _cur_time=_groups[_n_groups - 1].start + _groups[_n_groups - 1].gliss;

        return(1);
}


static int _pop_group(void)
/* finishes a group, moving the frame to the end of the longer part */
{
        if(_n_groups == 0)
        {
                _c_err("missing-start-of-group", NULL, NULL);
                return(0);
        }

        _n_groups--;

        _cur_time=_groups[_n_groups].max;

        return(1);
}


/* marks */

static void _add_mark(char * name)
/* creates a new mark */
{
        if(_n_marks == _marks_size)
        {
                _marks_size += 4;

                _marks=(struct _mark *) realloc(_marks,
                        _marks_size * sizeof(struct _mark));
        }

        strncpy(_marks[_n_marks].name, name, sizeof(_marks[_n_marks].name));
        _marks[_n_marks].time=_cur_time;

        _n_marks++;
}


static void _find_mark(char * name, int set)
/* finds a mark by name, optionally moving time cursor there */
{
        int n;

        for(n=0;n < _n_marks;n++)
        {
                if(strcmp(_marks[n].name, name) == 0)
                {
                        if(set)
                        {
                                if(_cur_time > _marks[n].time)
                                        _c_err("mark-overpassed", name, NULL);
                                else
                                        _cur_time=_marks[n].time;
                        }
                        else
                        if(_cur_time != _marks[n].time)
                                _c_err("mark-mismatch", name, NULL);

                        return;
                }
        }

        _c_err("mark-not-found", name, NULL);
}


/* arpeggiator */

static void _arp_default(void)
/* resets arpeggiator values to the default ones */
{
        _arp_delay=0.0;
        _arp_transpose=0;
        _arp_volume=1.0;
        _arp_track=_track;
}


static void _add_arp(void)
/* adds an arpeggiator note */
{
        /* if the note is exactly the same, do nothing */
        if(_arp_delay == 0.0 && _arp_transpose == 0 &&
           _arp_volume == 1.0 && _arp_track == _track)
                return;

        if(_n_arps == _arps_size)
        {
                _arps_size += 4;

                _arps=(struct _arp *) realloc(_arps,
                        _arps_size * sizeof(struct _arp));
        }

        _arps[_n_arps].delay=_arp_delay;
        _arps[_n_arps].transpose=_arp_transpose;
        _arps[_n_arps].volume=_arp_volume;
        _arps[_n_arps].track=_arp_track;

        _n_arps++;
        _arp_default();
}


/* song events */

static void _add_note_event(int note)
/* adds a note event */
{
        int n;
        int np;
        union song_ev e;

        /* calculate the note */
        np=note + _transpose + (_octave * 12);

        /* is note out of range? */
        if(np < 0 || np > 127)
        {
                _c_err("note-out-of-range", NULL, NULL);
                return;
        }

        e.note.type=SONG_EV_NOTE;
        e.note.time=_cur_time;
        e.note.trk_id=_track;
        e.note.note=np;
        e.note.len=_length * _staccato;
        e.note.vol=_volume;

        add_song_ev(&e);

        printf("Note(%d): %lf %d %lf %lf\n",
                _track, _cur_time, np, _length, _volume);

        /* add arpeggiator repetitions */
        for(n=0;n < _n_arps;n++)
        {
                e.note.time=_cur_time + _arps[n].delay;
                e.note.trk_id=_arps[n].track;
                e.note.note=np + _arps[n].transpose;
                e.note.vol=_volume * _arps[n].volume;

                add_song_ev(&e);
        }
}


static void _add_tempo_event(int trk_id, double tempo)
{
        union song_ev e;

        e.tempo.type=SONG_EV_TEMPO;
        e.tempo.time=_cur_time;
        e.tempo.trk_id=trk_id;
        e.tempo.tempo=tempo;
        add_song_ev(&e);
}


static void _add_meter_event(int trk_id, int num, int den)
{
        union song_ev e;

        e.meter.type=SONG_EV_METER;
        e.meter.time=_cur_time;
        e.meter.trk_id=trk_id;
        e.meter.num=num;
        e.meter.den=den;
        add_song_ev(&e);
}

static void _add_measure_event(void)
{
        union song_ev e;

        e.generic.type=SONG_EV_MEASURE;
        e.generic.time=_cur_time;
        e.generic.trk_id=-1;
        add_song_ev(&e);
}


static void _add_ss_sustain_event(double sustain)
{
        union song_ev e;

        e.ss_sustain.type=SONG_EV_SS_SUSTAIN;
        e.ss_sustain.time=_cur_time;
        e.ss_sustain.trk_id=_track;
        e.ss_sustain.sustain=sustain;

        add_song_ev(&e);
}


static void _add_ss_wav_event(char * wav_file, int base, int min, int max,
        double loop_start, double loop_end)
{
        union song_ev e;

        e.ss_wav.type=SONG_EV_SS_WAV;
        e.ss_wav.time=_cur_time;
        e.ss_wav.trk_id=_track;
        e.ss_wav.file=wav_file;
        e.ss_wav.base=base;
        e.ss_wav.min=min;
        e.ss_wav.max=max;
        e.ss_wav.loop_start=loop_start;
        e.ss_wav.loop_end=loop_end;
        add_song_ev(&e);
}


static void _add_ss_pat_event(char * pat_file)
{
        union song_ev e;

        e.ss_pat.type=SONG_EV_SS_PAT;
        e.ss_pat.time=_cur_time;
        e.ss_pat.trk_id=_track;
        e.ss_pat.file=pat_file;

        add_song_ev(&e);
}


static void _add_ss_eff_event(int type, int channel, double size, float gain,
        double depth, double freq, double phase, float initial, float final)
{
        union song_ev e;

        e.ss_eff.type=type;
        e.ss_eff.time=_cur_time;
        e.ss_eff.trk_id=_track;
        e.ss_eff.channel=channel;
        e.ss_eff.size=size;
        e.ss_eff.gain=gain;
        e.ss_eff.depth=depth;
        e.ss_eff.freq=freq;
        e.ss_eff.phase=phase;
        e.ss_eff.initial=initial;
        e.ss_eff.final=final;

        add_song_ev(&e);
}


static void add_midi_channel_event(int channel)
{
        union song_ev e;

        e.midi_channel.type=SONG_EV_MIDI_CHANNEL;
        e.midi_channel.time=_cur_time;
        e.midi_channel.trk_id=_track;
        e.midi_channel.channel=channel;

        add_song_ev(&e);
}


static void add_midi_program_event(int program)
{
        union song_ev e;

        e.midi_program.type=SONG_EV_MIDI_PROGRAM;
        e.midi_program.time=_cur_time;
        e.midi_program.trk_id=_track;
        e.midi_program.program=program;

        add_song_ev(&e);
}


static void _init_track(void)
/* sets the default values for a new track */
{
        _cur_time=0.0;
        _length=0.0;
        _transpose=0;
        _staccato=0.8;
        _volume=0.75;
        _octave=5;
        _gliss=0;

        /* groups should not cross track boundaries */
        _n_groups=0;

        /* reset arpeggiator */
        _n_arps=0;
        _arp_default();
}


%}

%union {
        int i;
        double d;
        char * p;
};

%token <i> P_INTEGER S_INTEGER
%token <d> P_REAL S_REAL
%token <i> NOTE_P NOTE_T3 NOTE_T5
%token <p> NEW_MARK GOTO_MARK ASSERT_MARK

%token <p> BLOCK BLK_ASSIGN BLK_INSERT FILE_INSERT

%token <p> XC_STR
%token <i> XC_MSECS XC_ABSNOTE

%token SS_SEP SS_WAV SS_LOOP_WAV SS_PAT SS_SUSTAIN
%token SS_EFF_DELAY SS_EFF_ECHO SS_EFF_COMB SS_EFF_ALLPASS SS_EFF_FLANGER
%token SS_EFF_WOBBLE SS_EFF_SQWOBBLE SS_EFF_FADER SS_EFF_REVERB SS_EFF_OFF

%token MIDI_CHANNEL MIDI_PROGRAM MIDI_GENERIC

%type <i> integer note note_pitch rest
%type <d> real p_number number note_length

%type <d> arp_list arp_note
%type <i> xc_absnote

%%

script:
        script stmt             { ; }
        | /* NULL */
        ;

stmt:
        note                    {
                                        /* note event */
                                        _add_note_event($1);
                                        _forward();
                                }
        | rest                  {
                                        /* rest */
                                        _forward();
                                }
        | 'z' note_length       {
                                        /* zero note */
                                        _length=$2;
                                }
        | 'o' P_INTEGER         {
                                        /* absolute octave */
                                        _octave=$2;
                                }
        | 'o' S_INTEGER         {
                                        /* relative octave */
                                        _octave += $2;
                                }
        | 'v' P_INTEGER         {
                                        /* absolute volume */
                                        _volume=(float)$2;
                                }
        | 'v' P_REAL            {
                                        /* absolute volume */
                                        _volume=(float)$2;
                                }
        | 'v' S_REAL            {
                                        /* relative volume */
                                        _volume += (float)$2;
                                }
        | 't' integer           {
                                        /* transpose */
                                        _transpose=$2;
                                }
        | 's' p_number          {
                                        /* staccato */
                                        _staccato=$2;
                                }

        | '<'                   {
                                        /* start of group */
                                        _push_group();
                                }
        | ';'                   {
                                        /* group delimiter */
                                        _next_group_part();
                                }
        | '>'                   {
                                        /* end of group */
                                        _pop_group();
                                }
        | 'l' note_length       {
                                        /* glissando */
                                        _gliss=$2;
                                }

        | '|'                   {
                                        /* measure mark event */
                                        _add_measure_event();
                                }

        | NEW_MARK              {
                                        /* add new mark */
                                        _add_mark($1);
                                }
        | GOTO_MARK             {
                                        /* go to mark */
                                        _find_mark($1, 1);
                                }
        | ASSERT_MARK           {
                                        /* assert mark */
                                        _find_mark($1, 0);
                                }

        | '\\'                  {
                                        /* new track */

                                        _track++;
                                        _init_track();
                                }
        | 'T' p_number          {
                                        /* tempo setting */
                                        _add_tempo_event(-1, $2);
                                }
        | 'M' P_INTEGER '/' P_INTEGER {
                                        /* meter (time signature) setting */
                                        _add_meter_event(-1, $2, $4);
                                }

        | BLOCK '*' P_INTEGER   {
                                        /* repeat block */
                                        push_code($1, $3, 1);
                                }
        | BLOCK BLK_ASSIGN      {
                                        /* assign block */
                                        _set_named_block($2, $1);
                                }
        | BLK_INSERT            {
                                        /* insert named block */
                                        _insert_named_block($1);
                                }
        | FILE_INSERT           {
                                        /* insert file */
                                        _insert_file($1);
                                }

        | arp                   { ; }

        | xc_cmd                { ; }

        ;

integer:
        P_INTEGER               { $$ = $1; }
        | S_INTEGER             { $$ = $1; }
        ;

real:
        P_REAL                  { $$ = $1; }
        | S_REAL                { $$ = $1; }
        ;

p_number:
        P_INTEGER               { $$ = (double) $1; }
        | P_REAL                { $$ = $1; }
        ;

number:
        integer                 { $$ = (double) $1; }
        | real                  { $$ = $1; }
        ;

note:
        note_pitch              { $$ = $1; }
        | note note_length      { $$ = $1; _length=$2; }
        | note '~' number       { $$ = $1; DEBUGF("imm volume: %lf\n", $3); }
        ;

note_pitch:
        NOTE_P                  { $$ = $1; }
        | note_pitch '&'        { $$ = $1 - 1; }
        | note_pitch '#'        { $$ = $1 + 1; }
        | note_pitch '\''       { $$ = $1 + 12; }
        | note_pitch ','        { $$ = $1 - 12; }
        ;

note_length:
        P_INTEGER               { $$ = 1 / (double) $1; }
        | note_length NOTE_T3   { $$ = $1 * 2.0 / 3.0; }
        | note_length NOTE_T5   { $$ = $1 * 4.0 / 5.0; }
        | note_length '*' p_number { $$ = $1 * $3; }
        | note_length '.'       { $$ = $1 * 1.5; }
        ;

rest:
        'r'                     { ; }
        | rest note_length      {
                                        /* rest with length */
                                        _length=$2;
                                }
        ;

arp:
        'x'                     {
                                        /* empty arpeggiator */
                                        _n_arps=0;
                                        _arp_default();
                                }
        | 'x' arp_list          { ; }
        ;

arp_list:
        arp_note                {
                                        /* first arpeggiator note */
                                        _n_arps=0;
                                        _add_arp();
                                }
        | arp_list ',' arp_note {
                                        /* rest of arpeggiator notes */
                                        _add_arp();
                                }
        ;

arp_note:
        note_length             {
                                        /* arpeggiator delay */
                                        _arp_delay=$1;
                                }
        | arp_note '~' number   {
                                        /* arpeggiator volume */
                                        _arp_volume=(float)$3;
                                }
        | arp_note S_INTEGER    {
                                        /* arpeggiator transpose */
                                        _arp_transpose=$2;
                                }
        | arp_note '@' P_INTEGER {
                                        /* arpeggiator track */
                                        _arp_track=$3;
                                }
        ;

xc_absnote:
        P_INTEGER               { $$ = $1; }
        | XC_ABSNOTE            { $$ = $1; }
        ;

xc_cmd:
        SS_WAV XC_STR xc_absnote xc_absnote xc_absnote {
                                        /* load .wav file */
                                        _add_ss_wav_event($2, $3, $4, $5, -1.0, -1.0);
                                }
        | SS_WAV XC_STR xc_absnote xc_absnote xc_absnote number number {
                                        /* load .wav file, with loop boundaries */
                                        _add_ss_wav_event($2, $3, $4, $5, $6, $7);
                                }
        | SS_PAT XC_STR         {
                                        /* load .pat file */
                                        _add_ss_pat_event($2);
                                }
        | SS_SUSTAIN XC_MSECS   {
                                        /* sets sustain */
                                        _add_ss_sustain_event($2);
                                }
        | SS_EFF_DELAY integer XC_MSECS {
                                        /* delay effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_DELAY,
                                        $2, $3, 0, 0, 0, 0, 0, 0);
                                }

        | SS_EFF_ECHO integer XC_MSECS number {
                                        /* echo effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_ECHO,
                                        $2, $3, $4, 0, 0, 0, 0, 0);
                                }

        | SS_EFF_COMB integer XC_MSECS number {
                                        /* comb effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_COMB,
                                        $2, $3, $4, 0, 0, 0, 0, 0);
                                }

        | SS_EFF_ALLPASS integer XC_MSECS number {
                                        /* allpass effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_ALLPASS,
                                        $2, $3, $4, 0, 0, 0, 0, 0);
                                }

        | SS_EFF_FLANGER integer XC_MSECS number XC_MSECS number number {
                                        /* flanger effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_FLANGER,
                                        $2, $3, $4, $5, $6, $7, 0, 0);
                                }

        | SS_EFF_WOBBLE integer number number {
                                        /* wobble effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_WOBBLE,
                                        $2, 0, 0, 0, $3, $4, 0, 0);
                                }

        | SS_EFF_SQWOBBLE integer number number {
                                        /* square wobble effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_SQWOBBLE,
                                        $2, 0, 0, 0, $3, $4, 0, 0);
                                }

        | SS_EFF_FADER integer XC_MSECS number number {
                                        /* fader effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_FADER,
                                        $2, $3, 0, 0, 0, 0, $4, $5);
                                }

        | SS_EFF_REVERB integer {
                                        /* reverb effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_REVERB,
                                        $2, 0, 0, 0, 0, 0, 0, 0);
                                }

        | SS_EFF_OFF integer {
                                        /* off effect */
                                        _add_ss_eff_event(SONG_EV_SS_EFF_OFF,
                                        $2, 0, 0, 0, 0, 0, 0, 0);
                                }

        | MIDI_CHANNEL integer {
                                        /* midi channel */
                                        add_midi_channel_event($2);
                                }

        | MIDI_PROGRAM integer {
                                        /* midi program */
                                        add_midi_program_event($2);
                                }
        ;

%%

void yyerror(char * s)
{
        _c_err(s, NULL, NULL);
}

#ifdef QQ
int main(void)
{
        _init_track();

        push_code("!this-is-a-mark", 1, 0);
        push_code("< c1 ; e& ; g>", 1, 0);
        push_code("^this-is-a-mark", 1, 0);
        push_code("x4,2-1,2.+4", 1, 0);
        push_code("a b'' c,, ", 1, 0);
        push_code("v0.1 (d8 v+0.1)*10", 1, 0);
        push_code("t1 t-2 t+3", 1, 0);
        push_code("{ fader -1 100ms 0 1 } r r4. z2 `room_kit.ahs` o4 o+1 o-2 ", 1, 0);
        push_code("{ sustain 100ms }", 1, 0);
        push_code("T120.0 M4/4 z8 abcde T80 (edcba)=drum1 $drum1 $drum1 ((a&b)*3 (cd)*2)*10", 2, 0);

        yyparse();

        printf("Exiting main...\n");
        exit(0);
}
#endif

static void compile_startup(void)
{
        _track=0;
        yyline=1;
        compiler_error=0;

        /* default settings */
        _add_tempo_event(-2, 120.0);
        _add_meter_event(-2, 4, 4);
        _init_track();
}


int compile(char * code)
{
        compile_startup();

        push_code(code, 1, 0);

        return(yyparse() + compiler_error);
}


int compile_file(char * file)
{
        compile_startup();

        if(_insert_file(file))
                return(1);

        return(yyparse() + compiler_error);
}