ExtendedInstruction.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/calculator/ExtendedInstruction.h#5 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2004-2009 SQLstream, Inc.
// Copyright (C) 2009-2009 LucidEra, Inc.
//
// 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 approved by The Eigenbase Project.
//
// 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
*/

#ifndef Fennel_ExtendedInstruction_Included
#define Fennel_ExtendedInstruction_Included

#include "fennel/calculator/Instruction.h"
#include "fennel/calculator/Calculator.h"
#include "fennel/calculator/ExtendedInstructionContext.h"

#include <boost/scoped_ptr.hpp>

FENNEL_BEGIN_NAMESPACE

using std::string;
class Register;
class ExtendedInstruction;


class FENNEL_CALCULATOR_EXPORT ExtendedInstructionDef
{
protected:
    string _name;
    vector<StandardTypeDescriptorOrdinal> _parameterTypes;
    string _signature;

    friend class ExtendedInstructionTable;

    explicit
    ExtendedInstructionDef(
        string const &name,
        vector<StandardTypeDescriptorOrdinal> const &parameterTypes)
        : _name(name),
          _parameterTypes(parameterTypes),
          _signature(computeSignature())
    {
    }
public:
    virtual
    ~ExtendedInstructionDef() {}

    string getName()
    {
        return _name;
    }

    const vector<StandardTypeDescriptorOrdinal> &getParameterTypes()
    {
        return _parameterTypes;
    }
    string getSignature() const
    {
        return _signature;
    }

    virtual ExtendedInstruction *createInstruction(
        vector<RegisterReference *> const &regs) = 0;

private:
    string computeSignature();
};

template <typename T>
class FunctorExtendedInstructionDef : public ExtendedInstructionDef
{
    friend class ExtendedInstructionTable;

protected:
    explicit
    FunctorExtendedInstructionDef(
        string const &name,
        vector<StandardTypeDescriptorOrdinal> const &parameterTypes,
        typename T::Functor functor)
        : ExtendedInstructionDef(name, parameterTypes),
          _functor(functor)
    {
        assert(functor != NULL);
    }
public:
    typename T::Functor _functor;

    // implement ExtendedInstructionDef
    ExtendedInstruction *createInstruction(
        vector<RegisterReference *> const &regs)
    {
        return T::create(*this,regs);
    }
};



class FENNEL_CALCULATOR_EXPORT ExtendedInstruction
    : public Instruction
{
protected:
    virtual ExtendedInstructionDef const &getDef() const = 0;

    template <typename T>
    static void describeArg(
        string &out,
        bool values,
        RegisterRef<T> * const reg)
    {
        out += reg->toString();
        if (values) {
            out += " ( ";
            if (reg->isNull()) {
                out += "NULL";
            } else {
                out += reg->valueToString();
            }
            out += " ) ";
        }
    }

public:
    explicit
    ExtendedInstruction()
    {}

    // implement Instruction
    const char *longName() const
    {
        return const_cast<ExtendedInstructionDef &>(getDef()).getName().c_str();
    }

    const char *shortName() const
    {
        return const_cast<ExtendedInstructionDef &>(getDef()).getName().c_str();
    }
};

class FENNEL_CALCULATOR_EXPORT ExtendedInstruction0
    : public ExtendedInstruction
{
public:
    typedef void (*Functor)();
    typedef FunctorExtendedInstructionDef<ExtendedInstruction0> DefT;

protected:
    DefT _def;

    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return static_cast<ExtendedInstructionDef const &>(_def);
    }

public:
    explicit
    ExtendedInstruction0(DefT &def)
        : ExtendedInstruction(),
          _def(def)
    {}

    static ExtendedInstruction0 *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 0);
        return new ExtendedInstruction0(def);
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "'";
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)();
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

class FENNEL_CALCULATOR_EXPORT ExtendedInstruction0Context
    : public ExtendedInstruction
{
public:
    typedef void (*Functor)(boost::scoped_ptr<ExtendedInstructionContext>& ctx);
    typedef FunctorExtendedInstructionDef<ExtendedInstruction0Context> DefT;

protected:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;

    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return static_cast<ExtendedInstructionDef const &>(_def);
    }

public:
    explicit
    ExtendedInstruction0Context(DefT &def)
        : ExtendedInstruction(),
          _def(def),
          _ctx(0)
    {}

    static ExtendedInstruction0Context *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 0);
        return new ExtendedInstruction0Context(def);
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "'";
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx));
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0>
class ExtendedInstruction1 : public ExtendedInstruction
{
public:
    typedef void (*Functor)(RegisterRef<T0>* reg0);
    typedef FunctorExtendedInstructionDef<ExtendedInstruction1<T0> > DefT;

private:
    DefT _def;
    RegisterRef<T0>* _reg0;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction1(
        DefT &def,
        RegisterRef<T0>* const reg0)
        : _def(def),
          _reg0(reg0)
    {}

    static ExtendedInstruction1<T0> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 1);
        // todo:        assert(regRefs[0].getType() == T0::typeCode);
        return new ExtendedInstruction1<T0>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)(_reg0);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0>
class ExtendedInstruction1Context : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        boost::scoped_ptr<ExtendedInstructionContext>& ctx,
        RegisterRef<T0>* reg0);

    typedef FunctorExtendedInstructionDef<ExtendedInstruction1Context<T0> >
        DefT;

private:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;
    RegisterRef<T0>* _reg0;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction1Context(
        DefT &def,
        RegisterRef<T0>* const reg0)
        : _def(def),
          _ctx(0),
          _reg0(reg0)
    {}

    static ExtendedInstruction1Context<T0> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 1);
        // todo:        assert(regRefs[0].getType() == T0::typeCode);
        return new ExtendedInstruction1Context<T0>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx),
                _reg0);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1>
class ExtendedInstruction2 : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1);
    typedef FunctorExtendedInstructionDef<ExtendedInstruction2<T0,T1> > DefT;

private:
    DefT _def;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction2(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1)
        : _def(def),
          _reg0(reg0),
          _reg1(reg1)
    {}

    static ExtendedInstruction2<T0,T1> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 2);
        return new ExtendedInstruction2<T0,T1>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)(_reg0,_reg1);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1>
class ExtendedInstruction2Context : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        boost::scoped_ptr<ExtendedInstructionContext>& ctx,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1);

    typedef FunctorExtendedInstructionDef<ExtendedInstruction2Context<T0,T1> >
        DefT;

private:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction2Context(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1)
        : _def(def),
          _ctx(0),
          _reg0(reg0),
          _reg1(reg1)
    {}

    static ExtendedInstruction2Context<T0,T1> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 2);
        return new ExtendedInstruction2Context<T0,T1>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx),
                _reg0,
                _reg1);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1, typename T2>
class ExtendedInstruction3 : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2);
    typedef FunctorExtendedInstructionDef<ExtendedInstruction3<T0,T1,T2> > DefT;

private:
    DefT _def;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction3(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2)
        : _def(def),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2)
    {}

    static ExtendedInstruction3<T0,T1,T2> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 3);
        return new ExtendedInstruction3<T0,T1,T2>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)(_reg0,_reg1,_reg2);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1, typename T2>
class ExtendedInstruction3Context : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        boost::scoped_ptr<ExtendedInstructionContext>& ctx,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2);
    typedef
        FunctorExtendedInstructionDef<ExtendedInstruction3Context<T0,T1,T2> >
        DefT;

private:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction3Context(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2)
        : _def(def),
          _ctx(0),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2)
    {}

    static ExtendedInstruction3Context<T0,T1,T2> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 3);
        return new ExtendedInstruction3Context<T0,T1,T2>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx),
                _reg0, _reg1, _reg2);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1, typename T2, typename T3>
class ExtendedInstruction4 : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3);
    typedef FunctorExtendedInstructionDef<
        ExtendedInstruction4<T0,T1,T2,T3> > DefT;

private:
    DefT _def;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;
    RegisterRef<T3>* _reg3;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction4(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3)
        : _def(def),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2),
          _reg3(reg3)
    {}

    static ExtendedInstruction4<T0,T1,T2,T3> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 4);
        return new ExtendedInstruction4<T0,T1,T2,T3>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]),
            static_cast<RegisterRef<T3> *>(regRefs[3]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
        out += ", ";
        describeArg(out, values, _reg3);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)(_reg0,_reg1,_reg2,_reg3);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};
template <typename T0, typename T1, typename T2, typename T3>
class ExtendedInstruction4Context : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        boost::scoped_ptr<ExtendedInstructionContext>& ctx,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3);

    typedef FunctorExtendedInstructionDef<
        ExtendedInstruction4Context<T0,T1,T2,T3> > DefT;

private:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;
    RegisterRef<T3>* _reg3;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction4Context(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3)
        : _def(def),
          _ctx(0),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2),
          _reg3(reg3)
    {}

    static ExtendedInstruction4Context<T0,T1,T2,T3> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 4);
        return new ExtendedInstruction4Context<T0,T1,T2,T3>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]),
            static_cast<RegisterRef<T3> *>(regRefs[3]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
        out += ", ";
        describeArg(out, values, _reg3);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx),
                _reg0, _reg1, _reg2, _reg3);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1, typename T2, typename T3, typename T4>
class ExtendedInstruction5 : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3,
        RegisterRef<T4>* const reg4);

    typedef FunctorExtendedInstructionDef<
        ExtendedInstruction5<T0,T1,T2,T3,T4> > DefT;

private:
    DefT _def;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;
    RegisterRef<T3>* _reg3;
    RegisterRef<T4>* _reg4;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction5(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3,
        RegisterRef<T4>* const reg4)
        : _def(def),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2),
          _reg3(reg3),
          _reg4(reg4)
    {}

    static ExtendedInstruction5<T0,T1,T2,T3,T4> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 5);
        return new ExtendedInstruction5<T0,T1,T2,T3,T4>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]),
            static_cast<RegisterRef<T3> *>(regRefs[3]),
            static_cast<RegisterRef<T4> *>(regRefs[4]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
        out += ", ";
        describeArg(out, values, _reg3);
        out += ", ";
        describeArg(out, values, _reg4);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            (*_def._functor)(_reg0,_reg1,_reg2,_reg3,_reg4);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};

template <typename T0, typename T1, typename T2, typename T3, typename T4>
class ExtendedInstruction5Context : public ExtendedInstruction
{
public:
    typedef void (*Functor)(
        boost::scoped_ptr<ExtendedInstructionContext>& ctx,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3,
        RegisterRef<T4>* const reg4);

    typedef FunctorExtendedInstructionDef<
        ExtendedInstruction5Context<T0,T1,T2,T3,T4> > DefT;

private:
    DefT _def;
    boost::scoped_ptr<ExtendedInstructionContext> _ctx;
    RegisterRef<T0>* _reg0;
    RegisterRef<T1>* _reg1;
    RegisterRef<T2>* _reg2;
    RegisterRef<T3>* _reg3;
    RegisterRef<T4>* _reg4;

protected:
    // implement ExtendedInstruction
    ExtendedInstructionDef const &getDef() const
    {
        return _def;
    }

public:
    explicit
    ExtendedInstruction5Context(
        DefT &def,
        RegisterRef<T0>* const reg0,
        RegisterRef<T1>* const reg1,
        RegisterRef<T2>* const reg2,
        RegisterRef<T3>* const reg3,
        RegisterRef<T4>* const reg4)
        : _def(def),
          _ctx(0),
          _reg0(reg0),
          _reg1(reg1),
          _reg2(reg2),
          _reg3(reg3),
          _reg4(reg4)
    {}

    static ExtendedInstruction5Context<T0,T1,T2,T3,T4> *create(
        DefT &def,
        vector<RegisterReference *> const &regRefs)
    {
        assert(regRefs.size() == 5);
        return new ExtendedInstruction5Context<T0,T1,T2,T3,T4>(
            def,
            static_cast<RegisterRef<T0> *>(regRefs[0]),
            static_cast<RegisterRef<T1> *>(regRefs[1]),
            static_cast<RegisterRef<T2> *>(regRefs[2]),
            static_cast<RegisterRef<T3> *>(regRefs[3]),
            static_cast<RegisterRef<T4> *>(regRefs[4]));
    }

    // implement Instruction
    void describe(string& out, bool values) const
    {
        out = "CALL '";
        out += _def.getSignature();
        out += "' ";
        describeArg(out, values, _reg0);
        out += ", ";
        describeArg(out, values, _reg1);
        out += ", ";
        describeArg(out, values, _reg2);
        out += ", ";
        describeArg(out, values, _reg3);
        out += ", ";
        describeArg(out, values, _reg4);
    }
    void exec(TProgramCounter &pc) const
    {
        pc++;
        try {
            // TODO: Remove this const cast. Ugly, but exec is defined as const
            // TODO: in virtual above.
            (*_def._functor)(
                const_cast<boost::scoped_ptr<ExtendedInstructionContext>& >(
                    _ctx),
                _reg0, _reg1, _reg2, _reg3, _reg4);
        } catch (char const * str) {
            throw CalcMessage(str, pc - 1);
        }
    }
};


FENNEL_END_NAMESPACE

#endif

// End ExtendedInstruction.h

---