source: to-imperative/trunk/opents/samples/trefal.hh @ 3664

/* $Id$ */
/* vim: set syntax=cpp shiftwidth=4 expandtab tabstop=4: */

#include <iostream>

#define DBG fprintf(stderr,"%d: %d\n",ts::myRank,__LINE__)

class Expr;

class TExpr : public ts::TVar<Expr>
{
public:
    bool operator== (TExpr& _e);
    TExpr operator+ (TExpr& _e);
    TExpr (TExpr& _e, size_t _start, size_t len); // subexpression
    TExpr (TExpr& _e, size_t _pos);             // dereference
};

struct Term {
    enum Type {
        CHAR, INT, EXPR
    } type;
    char c;
    int i;
    TExpr e;

    void init (char _c) {
        type = CHAR;
        c = _c;
        i = 0;
        (Expr&)e;
    }

    void init (int _i) {
        type = INT;
        c = 0;
        i = _i;
        (Expr&)e;
    }

    void init (const TExpr& _e) {
        type = EXPR;
        c = 0;
        i = 0;
        e = _e;
    }
};

inline bool operator== (Term& _t1, Term& _t2) {
    return _t1.type == _t2.type && _t1.c == _t2.c && _t1.i == _t2.i && _t1.e == _t2.e;
}

inline bool operator!= (Term& _t1, Term& _t2) {
    return !(_t1 == _t2);
}

class Expr : private ts::TExtData
{
    private:

        Term* terms;

        void copyFrom (const Expr& e, size_t start, size_t length) {
            Term* p = *this;
            const Term* q = ((const Term*) e) + start;
            if (terms)
                for (unsigned i = 0; i < length; i++)
                    *(p++) = *(q++);
            else
                for (unsigned i = 0; i < length; i++)
                    new (p++) Term(*q++);
        }

        void clear () {
            if (terms) {
                delete[] terms;
                terms = 0;
            } else {
                Term* p = *this;
                size_t length = get_len();
                for (unsigned i = 0; i < length; i++)
                    p++->~Term();
            }
        }

    public:

        Expr () : terms(0) {};

        void init (size_t s) {
            assert(!terms);
            terms = new Term[s];
            extDataSize() = s * sizeof(Term);
        };

        void init_str (const char* str, size_t len) {
            init(len);
            for (unsigned i = 0; i < len; i++)
                terms[i].init(str[i]);
        }

        void init_subexpr (const Expr& e, size_t start, size_t len) {
            init(len);
            copyFrom(e, start, len);
        }

        void init_paren (const TExpr& te) {
            init(1);
            terms->init(te);
        }

        void init_concat (const Expr** exprs, size_t num) {
            assert(!terms);
            size_t len = 0;
            for (unsigned i = 0; i < num; i++)
                len += exprs[i]->get_len();
            terms = new Term[len];
            extDataSize() = len * sizeof(Term);
            Term* p = terms;
            for (unsigned i = 0; i < num; i++) {
                const Term* q = *exprs[i];
                for (unsigned j = 0; j < exprs[i]->get_len(); j++)
                    *p++ = *q++;
            }
        }

        operator const Term* () const { return terms ? terms : (Term*)extData(); }
        operator       Term* ()       { return terms ? terms : (Term*)extData(); }

        Expr (const Expr& e) : terms(0) {
            copyFrom(e, 0, e.get_len());
        }

        Expr& operator= (const Expr& e) {
            if (this != &e) {
                clear();
                init(e.get_len());
                copyFrom(e, 0, e.get_len());
            }
            return *this;
        }

        Expr subexpr (size_t start, size_t length) const {
            Expr e;
            e.init(length);
            e.copyFrom(*this, start, length);
            return e;
        }

//        Expr operator() () const {
//            Expr e;
//            e.init(1);
//            Term* p = (Term *)e;
//            p->type = Term::EXPR;
//            p->e = *this;
//            p->c = 0;
//            p->i = 0;
//            return e;
//        }

        size_t get_len () const {
            return extDataSize() / sizeof(Term);
        }

        Term& operator[] (int i) {
            return ((Term *)*this)[i];
        }

        bool symbol_at (size_t pos) {
            return ((Term *)*this)[pos].type != Term::EXPR;
        }

        ~Expr () {
            clear();
        }
};

// e and t are intentionally not const!

std::ostream& operator<< (std::ostream& os, Expr& e);

std::ostream& operator<< (std::ostream& os, Term& t) {
    switch (t.type) {
        case Term::CHAR: os << t.c; break;
        case Term::INT:  os << t.i; break;
        case Term::EXPR: os << (Expr &)t.e; break;
    }
    return os;
}

std::ostream& operator<< (std::ostream& os, Expr& e) {
    os << "(";
    Term* p = e;
    for (unsigned i = 0; i < e.get_len(); i++)
        os << (i > 0 ? " " : "") << p[i];
    os << ")";
    return os;
}

std::istream& operator>> (std::istream& is, Expr& e);

std::istream& operator>> (std::istream& is, Term& t) {
    char c;
    is >> c;
    is.putback(c);
    if ('A' <= c && c <= 'Z') {
        t.type = Term::CHAR;
        is >> t.c;
        t.i = 0;
        (Expr &)(t.e);
    } else if ('0' <= c && c <= '9') {
        t.type = Term::INT;
        is >> t.i;
        t.c = 0;
        (Expr &)(t.e);
    } else if (c == '(') {
        t.type = Term::EXPR;
        t.c = 0;
        t.i = 0;
        is >> (Expr &)(t.e);
    } else {
        throw 0; //FIXME
    }
    return is;
}

std::istream& operator>> (std::istream& is, Expr& e) {
    int buffer_size = 20;
    Term* buffer = new Term[buffer_size];
    char c;
    is >> c;
    assert(c == '(');
    int len = 0;
    for (;len < buffer_size; len++) {
        is >> c;
        if (c == ')')
            break;
        is.putback(c);
        is >> buffer[len];
    }
    e.init(len);
    Term* p = e;
    for (int i = 0; i < len; i++)
        p[i] = buffer[i];
    delete[] buffer;
    return is;
}

Expr operator+ (const Expr& e1, const Expr& e2) {
    Expr e;
    e.init(e1.get_len() + e2.get_len());
    Term* p = e;
    const Term* q = e1;
    for (unsigned i = 0; i < e1.get_len(); i++)
        new (p++) Term(*q++);
    q = e2;
    for (unsigned i = 0; i < e2.get_len(); i++)
        new (p++) Term(*q++);
    return e;
}

inline bool operator== (Expr& _e1, Expr& _e2) {
    size_t len = _e1.get_len();
    if (len != _e2.get_len())
        return false;
    Term* p = _e1;
    Term* q = _e2;
    for (unsigned i = 0; i < len; i++)
        if (*p++ != *q++)
            return false;
    return true;
}

inline bool TExpr::operator== (TExpr& _e) {
    return d.cellOffset == _e.d.cellOffset || (Expr&)*this == (Expr&)_e;
}

inline TExpr TExpr::operator+ (TExpr& _e) {
    Expr*[] exprs = { &(Expr&)*this, &(Expr&)_e };
    TExpr e;
    ((Expr&)e).init_concat(exprs, 2);
    return e;
}

inline TExpr::TExpr (TExpr& _e, size_t _start, size_t len) {
    ((Expr&)*this).init_subexpr(_e, _start, _len);
}

inline TExpr::TExpr (TExpr& _e, size_t _pos) {
}