// Allegro: music representation system, with//      extensible in-memory sequence structure//      upward compatible with MIDI//      implementations in C++ and Serpent//      external, text-based representation//      compatible with Aura#ifndef __ALLEGRO__#define __ALLEGRO__#include <assert.h>#ifdef NEED_BOOL#define bool unsigned char#define true 1#define false 0#endif// are d1 and d2 within epsilon of each other?bool within(double d1, double d2, double epsilon);// abstract superclass of Allegro_note and Allegro_update:typedef class Allegro_event {public:    char type; // 'e' event, 'n' note, 'u' update    double time;    long chan;    virtual ~Allegro_event() {}} *Allegro_event_ptr;// a sequence of Event objectstypedef class Events {private:    long max;    void expand();public:    long len;    Allegro_event_ptr *events; // events is array of pointers    Allegro_event_ptr &operator[](int i) {       /* assert(i >= 0 && i < len);  dmazzoni */       if (i<0) i=0;       if (i>=len) i=len-1;       return events[i];    }    Events() {        max = 0;        len = 0;        events = NULL;    }    ~Events();    void insert(Allegro_event_ptr event);    void append(Allegro_event_ptr event);    void set_events(Allegro_event_ptr *e, long l, long m) {        if (events) delete [] events;        events = e; len = l; max = m; }} *Events_ptr;// Attribute is an atom in the symbol table// with the special addition that the last// character is prefixed to the string; thus,// the attribute 'tempor' (a real) is stored// as 'rtempor'. To get the string name, just// use attribute+1.typedef char *Attribute;// Atoms is a symbol table of Attributesclass Atoms {public:    Atoms() {        max = len = 0;        atoms = NULL;    }    // insert/lookup an atttribute    Attribute insert_attribute(Attribute attr);    // insert/lookup attribute by name (without prefixed type)    Attribute insert_string(const char *name);private:    long max;    long len;    char **atoms;    // insert an Attriubute not in table after moving attr to heap    Attribute insert_new(const char *name, char attr_type);    void expand(); // make more space};extern Atoms symbol_table;// an attribute/value pair. Since Attribute names imply type,// we try to keep attributes and values packaged together as// Parameter classtypedef class Parameter {private:    Attribute attr;public:    virtual ~Parameter();    union {        double r;// real        char *s; // string        long i;  // integer        bool l;  // logical        char *a; // symbol (atom)    }; // anonymous union    char attr_type() { return attr[0]; }    char *attr_name() { return attr + 1; }    void set_attr(Attribute a) { attr = a; }} *Parameter_ptr;// a list of attribute/value pairstypedef class Parameters {public:    class Parameters *next;    Parameter parm;    Parameters(Parameters *list) {        next = list;    }    // each of these routines takes address of pointer to the list    static void insert_real(Parameters **list, char *name, double r);    // insert string will copy string to heap    static void insert_string(Parameters **list, char *name, char *s);    static void insert_integer(Parameters **list, char *name, long i);    static void insert_logical(Parameters **list, char *name, bool l);    static void insert_atom(Parameters **list, char *name, char *s);    static Parameters *remove_key(Parameters **list, char *name);} *Parameters_ptr;typedef class Allegro_note: public Allegro_event {public:    virtual ~Allegro_note();    long key;     // note identifier    double pitch; // pitch in semitones (69 = A440)    double dur;   // duration in seconds (normally to release point)    double loud;  // dynamic corresponding to MIDI velocity    Parameters_ptr parameters; // attribute/value pair list    Allegro_note() { type = 'n'; parameters = NULL; }} *Allegro_note_ptr;typedef class Allegro_update: public Allegro_event {public:    virtual ~Allegro_update() {};    long key;     // note identifier (what sound is to be updated?)    Parameter parameter; // an update contains one attr/value pair       Allegro_update() { type = 'u'; }} *Allegro_update_ptr;// Beat is used to contruct a tempo maptypedef class Beat {public:    double time;    double beat;} *Beat_ptr;// Beats is a list of Beat objects used in Seqtypedef class Beats {private:    long max;    void expand();public:    long len;    Beat_ptr beats;    Beat &operator[](int i) {       if (i<0) i=0;       if (i>=len) i=len-1;       /* assert(i >= 0 && i < len); dmazzoni*/       return beats[i];    }    Beats() {        max = len = 0;        beats = NULL;        expand();        beats[0].time = 0;        beats[0].beat = 0;        len = 1;    }    ~Beats() {        if (beats) delete[] beats;    }    void insert(long i, Beat_ptr beat);} *Beats_ptr;class Time_map {public:    Beats beats; // array of Beat    double last_tempo;    bool last_tempo_flag;    Time_map() {        last_tempo = 1.0;        last_tempo_flag = false;    };    long locate_time(double time);    long locate_beat(double beat);    double beat_to_time(double beat);    double time_to_beat(double time);};// Time_sig represents a single time signature;// although not recommended, time_signatures may have arbitrary// floating point values, e.g. 4.5 beats per measuretypedef class Time_sig {public:    double beat; // when does this take effect?    double num;  // what is the "numerator" (top number?)    double den;  // what is the "denominator" (bottom number?)    Time_sig(double b, double n, double d) {        beat = b; num = n; den = d;    }    Time_sig() {        beat = 0; num = 0; den = 0;    }    void beat_to_measure(double beat, double *measure, double *m_beat,                         double *num, double *den);} *Time_sig_ptr;// Time_sigs is a dynamic array of time signaturesclass Time_sigs {private:    long max;    void expand(); // make more spacepublic:    long len;    Time_sig_ptr time_sigs;    Time_sigs() {        max = len = 0;        time_sigs = NULL;    }    Time_sig &operator[](int i) {        assert(i >= 0 && i < len);        return time_sigs[i];    }    ~Time_sigs() {        if (time_sigs) delete[] time_sigs;    }    void insert(double beat, double num, double den);};// A Seq is a sequence of Event, with a tempo map and // a sequence of time signatures//typedef class Seq {public:    Events notes; // array of Event    Time_map map;    Time_sigs time_sig;    int beat_x;    bool units_are_seconds;    Seq() {        units_are_seconds = true;    }    ~Seq();    long seek_time(double time);    void convert_to_beats();    void convert_to_seconds();    bool insert_beat(double time, double beat);    bool insert_tempo(double tempo, double beat);    void add_event(Allegro_event_ptr event);    bool set_tempo(double tempo, double start_beat, double end_beat);    void set_time_sig(double beat, double num, double den);    void beat_to_measure(double beat, long *measure, double *m_beat,                         double *num, double *den);    void set_events(Allegro_event_ptr *events, long len, long max);} *Seq_ptr;char *heapify(char *s);  // put a string on the heap#endif