lr_parser_methods.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_LR_PARSER_METHODS_H
#define ARCHON_UTILITIES_LR_PARSER_METHODS_H

#include <archon/util/lr_parser_base.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;


    template<class C>
    class LrParserBase::Actor<C>::MethodV0: public MethodBase
    {
      string name;
      void (C::*method)();
    public:
      MethodV0(string name, void (C::*method)()):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 0; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &) const
      {
        (context.*method)();
        return 0;
      }
    };

    template<class C>
    template<class R>
    class LrParserBase::Actor<C>::Method0: public MethodBase
    {
      string name;
      Ref<const R> (C::*method)();
    public:
      Method0(string name, Ref<const R> (C::*method)()):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 0; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &) const
      {
        return (context.*method)();
      }
    };



    template<class C>
    template<class A1>
    class LrParserBase::Actor<C>::MethodV1: public MethodBase
    {
      string name;
      void (C::*method)(const Ref<const A1> &);
    public:
      MethodV1(string name,
               void (C::*method)(const Ref<const A1> &)):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 1; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &args) const
      {
        const A1 *a1 = dynamic_cast<const A1 *>(args[0].get());
        if(!a1 && args[0]) ARCHON_THROW2(CallException, 0, typeid(A1));
        (context.*method)(a1);
        return 0;
      }
    };

    template<class C>
    template<class R, class A1>
    class LrParserBase::Actor<C>::Method1: public MethodBase
    {
      string name;
      Ref<const R> (C::*method)(const Ref<const A1> &);
    public:
      Method1(string name,
              Ref<const R> (C::*method)(const Ref<const A1> &)):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 1; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &args) const
      {
        const A1 *a1 = dynamic_cast<const A1 *>(args[0].get());
        if(!a1 && args[0]) ARCHON_THROW2(CallException, 0, typeid(A1));
        return (context.*method)(a1);
      }
    };



    template<class C>
    template<class A1, class A2>
    class LrParserBase::Actor<C>::MethodV2: public MethodBase
    {
      string name;
      void (C::*method)(const Ref<const A1> &,
                        const Ref<const A2> &);
    public:
      MethodV2(string name,
               void (C::*method)(const Ref<const A1> &,
                                 const Ref<const A2> &)):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 2; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &args) const
      {
        const A1 *a1 = dynamic_cast<const A1 *>(args[0].get());
        const A2 *a2 = dynamic_cast<const A2 *>(args[1].get());
        if(!a1 && args[0]) ARCHON_THROW2(CallException, 0, typeid(A1));
        if(!a2 && args[1]) ARCHON_THROW2(CallException, 1, typeid(A2));
        (context.*method)(a1, a2);
        return 0;
      }
    };

    template<class C>
    template<class R, class A1, class A2>
    class LrParserBase::Actor<C>::Method2: public MethodBase
    {
      string name;
      Ref<const R> (C::*method)(const Ref<const A1> &,
                                const Ref<const A2> &);
    public:
      Method2(string name,
              Ref<const R> (C::*method)(const Ref<const A1> &,
                                        const Ref<const A2> &)):
        name(name), method(method) {}

      string getName() const { return name; }
      int getArity() const { return 2; }

      RefAnyConst call(C &context, const vector<RefAnyConst> &args) const
      {
        const A1 *a1 = dynamic_cast<const A1 *>(args[0].get());
        const A2 *a2 = dynamic_cast<const A2 *>(args[1].get());
        if(!a1 && args[0]) ARCHON_THROW2(CallException, 0, typeid(A1));
        if(!a2 && args[1]) ARCHON_THROW2(CallException, 1, typeid(A2));
        return (context.*method)(a1, a2);
      }
    };
  }
}

#endif // ARCHON_UTILITIES_LR_PARSER_METHODS_H

---