Fixed ss_tempo_from_wave() algorithm.

[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 "annhell.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(double step)
/* moves forward current time */
{
        /* add step */
        cur_time += step;

        /* 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--;

        /* if other parts of group were longer than the last one,
           move pointer there */
        if(groups[n_groups].max > cur_time)
                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);

        /* 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.measure.type=SONG_EV_MEASURE;
        e.measure.time=cur_time;
        e.measure.trk_id=-1;
        e.measure.line=yyline;

        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_vibrato_event(double depth, double freq)
{
        union song_ev e;

        e.ss_vibrato.type=SONG_EV_SS_VIBRATO;
        e.ss_vibrato.time=cur_time;
        e.ss_vibrato.trk_id=track;
        e.ss_vibrato.vib_depth=depth;
        e.ss_vibrato.vib_freq=freq;

        add_song_ev(&e);
}


static void add_ss_channel_event(int channel, float vol)
{
        union song_ev e;

        e.ss_channel.type=SONG_EV_SS_CHANNEL;
        e.ss_channel.time=cur_time;
        e.ss_channel.trk_id=track;
        e.ss_channel.channel=channel;
        e.ss_channel.vol=vol;

        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_ss_pitch_stretch(int note, double len, float vol)
{
        union song_ev e;

        e.ss_pitch_stretch.type=SONG_EV_SS_PITCH_STRETCH;
        e.ss_pitch_stretch.time=cur_time;
        e.ss_pitch_stretch.trk_id=track;
        e.ss_pitch_stretch.note=note;
        e.ss_pitch_stretch.len=len;
        e.ss_pitch_stretch.vol=vol;

        add_song_ev(&e);
}


static void add_ss_print_wave_tempo(int note, double len)
{
        union song_ev e;

        e.ss_print_wave_tempo.type=SONG_EV_SS_PRINT_WAVE_TEMPO;
        e.ss_print_wave_tempo.time=cur_time;
        e.ss_print_wave_tempo.trk_id=track;
        e.ss_print_wave_tempo.note=note;
        e.ss_print_wave_tempo.len=len;

        add_song_ev(&e);
}


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

        /* 1st channel is 0 */
        channel--;

        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_ABSNOTE
%token <d> XC_MSECS

%token SS_SEP SS_WAV SS_LOOP_WAV SS_PAT SS_SUSTAIN SS_VIBRATO SS_CHANNEL SS_VOL

%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 SS_PITCH_STRETCH SS_TIME_STRETCH SS_PRINT_WAVE_TEMPO

%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(length);
                                }
        | rest                  {
                                        /* rest */
                                        forward(length);
                                }
        | '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 {
                                        /* load .wav file with just one note */
                                        add_ss_wav_event($2, $3, $3, $3, -1.0, -1.0);
                                }
        | 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_VIBRATO XC_MSECS number {
                                        /* sets vibrato */
                                        add_ss_vibrato_event($2, $3);
                                }
        | SS_CHANNEL integer number {
                                        /* sets volume for a channel */
                                        add_ss_channel_event($2, $3);
                                }
        | SS_VOL number number {
                                        /* set vol for 2 channels */
                                        add_ss_channel_event(0, $2);
                                        add_ss_channel_event(1, $3);
                                }
        | SS_VOL number number number {
                                        /* set vol for 3 channels */
                                        add_ss_channel_event(0, $2);
                                        add_ss_channel_event(1, $3);
                                        add_ss_channel_event(2, $4);
                                }
        | SS_VOL number number number number {
                                        /* set vol for 4 channels */
                                        add_ss_channel_event(0, $2);
                                        add_ss_channel_event(1, $3);
                                        add_ss_channel_event(2, $4);
                                        add_ss_channel_event(3, $5);
                                }
        | SS_VOL number number number number number number {
                                        /* set vol for 6 channels */
                                        add_ss_channel_event(0, $2);
                                        add_ss_channel_event(1, $3);
                                        add_ss_channel_event(2, $4);
                                        add_ss_channel_event(3, $5);
                                        add_ss_channel_event(4, $6);
                                        add_ss_channel_event(5, $7);
                                }
        | 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);
                                }

        | SS_PITCH_STRETCH xc_absnote number number {
                                        /* pitch stretch note */
                                        add_ss_pitch_stretch($2, $3, $4);

                                        forward($3);
                                }

        | SS_PRINT_WAVE_TEMPO xc_absnote number {
                                        /* print tempo from wave */
                                        add_ss_print_wave_tempo($2, $3);
                                }

        | 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);
}