root/todo/tags/0.1.20/util/Lexer.cc

#include "Lexer.h"

Lexer::Lexer() : initialised(false)
{
}

Lexer::~Lexer()
{
}

Lexer &Lexer::addPattern(unsigned index, char const *in, bool ignore)
{
        // This was to allow statically allocated Lexer's. If regexp's were
        // initialised globally, they may have been constructed before
        // the Regex::cache was initialised...this caused segfaults. Bad.
        if (!initialised)
        {
        Pattern &p = pattern[Character];

                try {
                        p.rx = ".";
                        p.ignore = false;
                        p.enabled = true;
                } catch (Regex::exception &e) {
                        throw runtime_error("Lexer::Lexer: index " + str::stringify(index) + ", " + string(e.what()));
                }
                initialised = true;
        }

        if (index < 256) throw runtime_error("pattern indices under 256 are reserved, relevant pattern is '" + string(in) + "'");

Pattern &p = pattern[index];

        try {
                p.rx = in;
                p.ignore = ignore;
                p.enabled = true;
        } catch (Regex::exception &e) {
                throw runtime_error("Lexer::addPattern: index " + str::stringify(index) + ", " + string(e.what()));
        }

        return *this;
}

bool Lexer::get(iterator &it, char const *&in, unsigned &line)
{
        if (*in == 0) 
                return false;

bool ignore;

        do {
                ignore = false;
                for (map<int, Pattern>::iterator i = pattern.begin(); i != pattern.end(); ++i)
                        if ((*i).second.enabled)
                        {
                        Pattern &p = (*i).second;
                        int length;

                                if ((length = p.rx.matchStart(in)) != -1)
                                {
                                        for (int j = 0; j < length; ++j)
                                                if (in[j] == '\n') line++;
                                        if (p.ignore)
                                        {
                                                in += length;
                                                ignore = true;
                                                if (*in == 0) return false;
                                                break;
                                        } else
                                        {
                                                it._value = string(in, length);
                                                it._line = line;
                                                // Handle individual characters
                                                if ((*i).first == Character)
                                                        it._type = *in;
                                                else
                                                        it._type = (*i).first;
                                                it.in = in;
                                                in += length;
                                                return true;
                                        }
                                }
                        }
        } while (ignore);
        return false;
}

void Lexer::ignore(unsigned index, bool state)
{
        if (pattern.find(index) == pattern.end())
                throw exception("tried to ignore/unignore an unknown token", 0);
        pattern[index].ignore = state;
}

void Lexer::enable(unsigned index, bool state)
{
        if (pattern.find(index) == pattern.end())
                throw exception("tried to enable/disable an unknown token", 0);
        pattern[index].enabled = state;
}