lexer.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_LEXER_H
#define ARCHON_UTILITIES_LEXER_H

#include <memory>
#include <vector>

#include <archon/util/ref.H>
#include <archon/util/unicode.H>
#include <archon/util/stream.H>
#include <archon/util/dfa.H>

#include <archon/util/regex.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct LexerBase
    {
      struct InputException: virtual Utilities::Exception
      {
        int lineNumber;
        ustring text;
        InputException(int lineNumber, ustring text):
          lineNumber(lineNumber), text(text) {}
        virtual ~InputException() throw() {}
        string getMessage() const throw();
      };

      struct Lexeme
      {
        int type;
        RefAny value;
        Lexeme(int type = -1, RefAny value = 0): type(type), value(value) {}
      };

      virtual ~LexerBase() {}

      virtual void getNext(Lexeme &l) = 0;

      virtual ustring getText() const = 0;

      virtual int getType() const = 0;
    };

    class Lexer: public LexerBase
    {
    public:
      struct Context
      {
        virtual ~Context() {}
        virtual void lexerError() = 0;
      };

      class ActorBase
      {
        friend class Lexer;

      protected:
        struct MethodBase: virtual RefObjectBase
        {
          virtual ~MethodBase() {}
          virtual void call(Context *, Lexeme &) const = 0;
        };

        vector<Ref<const MethodBase> > methods;

        virtual ~ActorBase() {}

        void call(int method, Context *c, Lexeme &l) const
        {
          methods[method]->call(c, l);
        }

        virtual bool verifyContext(const Context &) const = 0;
      };

      template<class C>
      class Actor: public ActorBase
      {
        bool verifyContext(const Context &c) const
        {
          return dynamic_cast<const C *>(&c);
        }

        class Method0: public MethodBase
        {
          void (C::*method)();

        public:
          Method0(void (C::*method)()): method(method) {}

          void call(Lexer::Context *c, Lexer::Lexeme &l) const
          {
            (static_cast<C *>(c)->*method)();
            l.type = -1;
          }
        };

        class Method1: public MethodBase
        {
          void (C::*method)(Lexeme &);

        public:
          Method1(void (C::*method)(Lexeme &)): method(method) {}

          void call(Context *c, Lexeme &l) const
          {
            (static_cast<C *>(c)->*method)(l);
          }
        };

        template<typename R>
        class Method2: public MethodBase
        {
          R (C::*method)();

        public:
          Method2(R (C::*method)()): method(method) {}

          void call(Context *c, Lexeme &l) const
          {
            l.value = new RefObject<R>((static_cast<C *>(c)->*method)());
          }
        };

      public:
        int registerMethod(void (C::*method)())
        {
          methods.push_back(new Method0(method));
          return methods.size()-1;
        }

        int registerMethod(void (C::*method)(Lexeme &))
        {
          methods.push_back(new Method1(method));
          return methods.size()-1;
        }

        template<typename R>
        int registerMethod(R (C::*method)())
        {
          methods.push_back(new Method2<R>(method));
          return methods.size()-1;
        }
      };

      class Engine;

      class RuleSet
      {
        friend class Engine;

        struct Rule
        {
          Regex regex;
          int method;
          Lexeme lexeme;
          Rule(const Regex &r, int method, Lexeme lexeme):
            regex(r), method(method), lexeme(lexeme) {}
        };

        vector<Rule> rules;

      public:
        template<typename L>
        void add(const Regex &r, int method, int terminal, L lexemeValue)
        {
          rules.push_back(Rule(r, method,
                               Lexeme(terminal,
                                      new RefObject<L>(lexemeValue))));
        }

        template<typename L>
        void add(const Regex &r, int method, int terminal, Ref<L> lexemeValue)
        {
          rules.push_back(Rule(r, method, Lexeme(terminal, lexemeValue)));
        }

        void add(const Regex &r, int method, int terminal, RefAny lexemeValue)
        {
          rules.push_back(Rule(r, method, Lexeme(terminal, lexemeValue)));
        }

        void add(const Regex &r, int method = -1, int terminal = -1)
        {
          rules.push_back(Rule(r, method, Lexeme(terminal, 0)));
        }
      };

      class Engine
      {
        friend class Lexer;

        struct Rule
        {
          int method;
          Lexeme lexeme;

          Rule(): method(-1) {}
          Rule(int method, Lexeme lexeme): method(method), lexeme(lexeme) {}
        };

        const ActorBase *actor;
        auto_ptr<DFA> dfa;
        vector<Rule> rules;

        // Bit patterns for the types of anchors. One for each state.
        vector<unsigned> anchorMasks;

        // Prevent copying
        Engine(const Engine &);
        Engine &operator=(const Engine &);

      public:
        Engine(const RuleSet &, const ActorBase * =0);
      };

    private:
      const Engine &engine;
      Ref<Stream::UReader> &reader; // Should this really be an alias???
      Context *context;
      ustring buffer;
      int bufferSize;
      int charCount;
      int type;
      int anchorState;
      int lineNumber;


    public:
      Lexer(const Engine &e, Ref<Stream::UReader> &r, Context *c=0):
        engine(e), reader(r), context(c), bufferSize(0), charCount(0),
        type(-1), anchorState(0), lineNumber(1) {}

      void getNext(Lexeme &);

      ustring getText() const
      {
        return buffer.substr(0, charCount);
      }

      int getType() const
      {
        return type;
      }

      int getLineNumber() const { return lineNumber; }
    };
  }
}

#endif // ARCHON_UTILITIES_LEXER_H

---